pythonic-fp.iterables 3.0.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

pythonic_fp/iterables.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Module fp.iterables - Iterator related tools
-
-Library of iterator related functions and enumerations.
+"""
+Library of functions for iterating iterables.
+---------------------------------------------
 
 - Concatenating and merging iterables
 - Dropping and taking values from iterables
@@ -26,6 +26,7 @@ Library of iterator related functions and enumerations.
 
     - all iterators are assumed to be iterable
     - for all iterators ``foo`` we assume ``iter(foo) is foo``
+
 """
 
 from __future__ import annotations
@@ -36,9 +37,9 @@ __license__ = 'Apache License 2.0'
 
 from collections.abc import Callable, Iterable, Iterator
 from enum import auto, Enum
-from typing import cast, Never, TypeVar
+from typing import cast, Never
 from pythonic_fp.containers.box import Box
-from pythonic_fp.containers.maybe import MayBe as MB
+from pythonic_fp.containers.maybe import MayBe
 from pythonic_fp.fptools.function import negate, swap
 from pythonic_fp.fptools.singletons import NoValue
 
@@ -54,27 +55,24 @@ __all__ = [
     'take_split',
     'take_while_split',
     'accumulate',
-    'foldl',
-    'mb_fold_left',
     'reduce_left',
+    'fold_left',
+    'maybe_fold_left',
     'sc_reduce_left',
     'sc_reduce_right',
 ]
 
-D = TypeVar('D')  # Needed only for pdoc documentation generation.
-L = TypeVar('L')  # Otherwise, ignored by both MyPy and Python.
-
 # Iterate over multiple iterables
 
 
 class FM(Enum):
-    """Types of iterable blending,
+    """Iterable Blending Enums.
 
-    - **CONCAT:** Concatenate first to last
-    - **MERGE:** Merge until one is exhausted
-    - **EXHAUST:** Merge until all are exhausted
-    """
+    - *CONCAT:* Concatenate iterables first to last
+    - *MERGE:* Merge iterables until one is exhausted
+    - *EXHAUST:* Merge iterables until all are exhausted
 
+    """
     CONCAT = auto()
     MERGE = auto()
     EXHAUST = auto()
@@ -83,10 +81,18 @@ class FM(Enum):
 def concat[D](*iterables: Iterable[D]) -> Iterator[D]:
     """Sequentially concatenate multiple iterables together.
 
+    .. code:: python
+
+        def concat[D](iterable: Iterable[D]) -> Iterator[D]
+
     - pure Python version of standard library's ``itertools.chain``
     - iterator sequentially yields each iterable until all are exhausted
     - an infinite iterable will prevent subsequent iterables from yielding any values
     - performant to ``itertools.chain``
+
+    :param iterables: iterables to concatenate
+    :return: concatenated iterators
+
     """
     for iterator in map(lambda x: iter(x), iterables):
         while True:
@@ -97,9 +103,47 @@ def concat[D](*iterables: Iterable[D]) -> Iterator[D]:
                 break
 
 
+def merge[D](*iterables: Iterable[D], yield_partials: bool = False) -> Iterator[D]:
+    """Shuffle together ``iterables`` until one is exhausted.
+
+    .. code:: python
+
+        def merge[D](iterable: Iterable[D], yield_partials: bool) -> Iterator[D]
+
+    If ``yield_partials`` is true
+
+    - yield any unmatched yielded values from other iterables
+    - prevents data lose if any of the iterables are iterators with external references
+
+    :param iterables: iterables to merge until one gets exhausted
+    :return: merged iterators
+
+    """
+    iter_list = list(map(lambda x: iter(x), iterables))
+    values = []
+    if (num_iters := len(iter_list)) > 0:
+        while True:
+            try:
+                for ii in range(num_iters):
+                    values.append(next(iter_list[ii]))
+                yield from values
+                values.clear()
+            except StopIteration:
+                break
+        if yield_partials:
+            yield from values
+
+
 def exhaust[D](*iterables: Iterable[D]) -> Iterator[D]:
     """Shuffle together multiple iterables until all are exhausted.
-    Iterator yields until all iterables are exhausted.
+
+    .. code:: python
+
+        def exhaust[D](iterable: Iterable[D]) -> Iterator[D]
+
+    :param iterables: iterables to exhaustively merge
+    :return: merged iterators
+
     """
     iter_list = list(map(lambda x: iter(x), iterables))
     if (num_iters := len(iter_list)) > 0:
@@ -122,37 +166,24 @@ def exhaust[D](*iterables: Iterable[D]) -> Iterator[D]:
         yield from values
 
 
-def merge[D](*iterables: Iterable[D], yield_partials: bool = False) -> Iterator[D]:
-    """Shuffle together the ``iterables`` until one is exhausted.
+## dropping and taking
 
-    - iterator yields until one of the iterables is exhausted
-    - if ``yield_partials`` is true,
 
-      - yield any unmatched yielded values from other iterables
-      - prevents data lose
+def drop[D](iterable: Iterable[D], n: int) -> Iterator[D]:
+    """Drop the next n values from iterable.
 
-        - if any of the iterables are iterators with external references
-    """
-    iter_list = list(map(lambda x: iter(x), iterables))
-    values = []
-    if (num_iters := len(iter_list)) > 0:
-        while True:
-            try:
-                for ii in range(num_iters):
-                    values.append(next(iter_list[ii]))
-                yield from values
-                values.clear()
-            except StopIteration:
-                break
-        if yield_partials:
-            yield from values
+    .. code:: python
 
+        def drop[D](
+            iterable: Iterable[D],
+            n: int
+        ) -> Iterator[D]
 
-## dropping and taking
-
+    :param iterable: iterable whose values are to be dropped
+    :param n: number of values to be dropped
+    :return: an iterator of the remaining values
 
-def drop[D](iterable: Iterable[D], n: int, /) -> Iterator[D]:
-    """Drop the next ``n`` values from ``iterable``."""
+    """
     it = iter(iterable)
     for _ in range(n):
         try:
@@ -162,8 +193,21 @@ def drop[D](iterable: Iterable[D], n: int, /) -> Iterator[D]:
     return it
 
 
-def drop_while[D](iterable: Iterable[D], pred: Callable[[D], bool], /) -> Iterator[D]:
-    """Drop initial values from ``iterable`` while predicate is true."""
+def drop_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[D]:
+    """Drop initial values from iterable while predicate is true.
+
+    .. code:: python
+
+        def drop_while[D](
+            iterable: Iterable[D],
+            pred: Callable[[D], bool]
+        ) -> Iterator[D]
+
+    :param iterable: iterable whose values are to be dropped
+    :param pred: Boolean valued function
+    :return: an iterator beginning where pred returned false
+
+    """
     it = iter(iterable)
     while True:
         try:
@@ -176,8 +220,21 @@ def drop_while[D](iterable: Iterable[D], pred: Callable[[D], bool], /) -> Iterat
     return it
 
 
-def take[D](iterable: Iterable[D], n: int, /) -> Iterator[D]:
-    """Return an iterator of up to ``n`` initial values of an iterable"""
+def take[D](iterable: Iterable[D], n: int) -> Iterator[D]:
+    """Return an iterator of up to n initial values of an iterable.
+
+    .. code:: python
+
+        def take[D](
+            iterable: Iterable[D],
+            n: int
+        ) -> Iterator[D]
+
+    :param iterable: iterable providing the values to be taken
+    :param n: number of values to be dropped
+    :return: an iterator of up to n initial values from iterable
+
+    """
     it = iter(iterable)
     for _ in range(n):
         try:
@@ -187,27 +244,23 @@ def take[D](iterable: Iterable[D], n: int, /) -> Iterator[D]:
             break
 
 
-def take_split[D](iterable: Iterable[D], n: int, /) -> tuple[Iterator[D], Iterator[D]]:
-    """Same as take except also return an iterator of the remaining values.
-
-    - return a tuple of
-
-      - an iterator of up to ``n`` initial values
-      - an iterator of the remaining vales of the ``iterable``
-
-    - Contract: do not access second iterator until first is exhausted
-    """
-    it = iter(iterable)
-    itn = take(it, n)
-
-    return itn, it
+def take_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[D]:
+    """Yield values from iterable while predicate is true.
 
+    .. code:: python
 
-def take_while[D](iterable: Iterable[D], pred: Callable[[D], bool], /) -> Iterator[D]:
-    """Yield values from ``iterable`` while predicate is true.
+        def take_while[D](
+            iterable: Iterable[D],
+            pred: Callable[[D], bool]
+        ) -> Iterator[D]
 
     .. warning::
         Risk of value loss if iterable is multiple referenced iterator.
+
+    :param iterable: iterable providing the values to be taken
+    :param pred: Boolean valued function
+    :return: an Iterator of up to n initial values from the iterable
+
     """
     it = iter(iterable)
     while True:
@@ -221,19 +274,54 @@ def take_while[D](iterable: Iterable[D], pred: Callable[[D], bool], /) -> Iterat
             break
 
 
+def take_split[D](iterable: Iterable[D], n: int) -> tuple[Iterator[D], Iterator[D]]:
+    """Same as take except also return iterator of remaining values.
+
+    .. code:: python
+
+        def take_split[D](
+            iterable: Iterable[D],
+            n: int
+        ) -> tuple[Iterator[D], Iterator[D]]
+
+    .. Warning::
+
+       **CONTRACT:** Do not access the second returned iterator until the
+       first one is exhausted.
+
+    :param iterable: iterable providing the values to be taken
+    :param n: maximum number of values to be taken
+    :return: an iterator of values taken and an iterator of remaining values
+
+    """
+    it = iter(iterable)
+    itn = take(it, n)
+
+    return itn, it
+
+
 def take_while_split[D](
-    iterable: Iterable[D], pred: Callable[[D], bool], /
+    iterable: Iterable[D], pred: Callable[[D], bool]
 ) -> tuple[Iterator[D], Iterator[D]]:
-    """Yield values from ``iterable`` while ``predicate`` is true.
+    """Yield values from iterable while predicate is true.
 
-    - return a tuple of two iterators
+    .. code:: python
 
-      - first of initial values where predicate is true, followed by first to fail
-      - second of the remaining values of the iterable after first failed value
+        def take_while_split[D](
+            iterable: Iterable[D],
+            pred: Callable[[D], bool]
+        ) -> tuple[Iterator[D], Iterator[D]]
 
-    - **Contract:** do not access second iterator until first is exhausted
-    """
+    .. Warning::
 
+       **CONTRACT:** Do not access the second returned iterator until
+       the first one is exhausted.
+
+    :param iterable: iterable providing the values to be taken
+    :param pred: Boolean valued function
+    :return: an iterator of values taken and an iterator of remaining values
+
+    """
     def _take_while(
         it: Iterator[D], pred: Callable[[D], bool], val: Box[D]
     ) -> Iterator[D]:
@@ -258,13 +346,30 @@ def take_while_split[D](
 
 
 def accumulate[D, L](
-    iterable: Iterable[D], f: Callable[[L, D], L], initial: L | NoValue = NoValue(), /
-) -> Iterator[L]:
-    """Returns an iterator of accumulated values.
+        iterable: Iterable[D],
+        f: Callable[[L, D], L],
+        initial: L | NoValue = NoValue()
+    ) -> Iterator[L]:
+    """Returns an iterator of partial fold values.
+
+    .. code:: python
+
+        def accumulate[D, L](
+            iterable: Iterable[D],
+            f: Callable[[L, D], L],
+            initial: L
+        ) -> Iterator[L]
+
+    A pure Python version of standard library's ``itertools.accumulate``
 
-    - pure Python version of standard library's ``itertools.accumulate``
     - function ``f`` does not default to addition (for typing flexibility)
-    - begins accumulation with an optional ``initial`` value
+    - begins accumulation with an "optional" ``initial`` value
+
+    :param iterable: iterable to be folded
+    :param f: 2 parameter function, first parameter for accumulated value
+    :param initial: "optional" initial value to start fold
+    :return: an iterator of the intermediate fold values
+
     """
     it = iter(iterable)
     try:
@@ -290,19 +395,36 @@ def accumulate[D, L](
             yield acc
 
 
-def reduce_left[D](iterable: Iterable[D], f: Callable[[D, D], D], /) -> D | Never:
+def reduce_left[D](iterable: Iterable[D], f: Callable[[D, D], D]) -> D | Never:
     """Fold an iterable left with a function.
 
-    - traditional FP type order given for function ``f``
-    - if iterable empty, ``StopIteration`` exception raised
-    - does not catch any exceptions ``f`` may raise
-    - never returns if ``iterable`` generates an infinite iterator
+    .. code:: python
+
+        def reduce_left[D](
+            iterable: Iterable[D],
+            f: Callable[[D, D], D]
+        ) -> D | Never
+
+    .. Warning::
+
+       This function never return if given an infinite iterable.
+
+    .. Warning::
+
+       This function does not catch or re-raises exceptions from ``f``.
+
+    :param iterable: iterable to be reduced (folded)
+    :param f: 2 parameter function, first parameter for accumulated value
+    :return: reduced value from the iterable
+    :raises StopIteration: when called on an empty circular array
+    :raises Exception: does not catch or re-raises exceptions from ``f``.
+
     """
     it = iter(iterable)
     try:
         acc = next(it)
     except StopIteration as exc:
-        msg = 'Attemped to reduce an empty iterable.'
+        msg = 'Attempt to reduce an empty iterable?'
         raise StopIteration(msg) from exc
 
     for v in it:
@@ -311,20 +433,38 @@ def reduce_left[D](iterable: Iterable[D], f: Callable[[D, D], D], /) -> D | Neve
     return acc
 
 
-def foldl[D, L](
-    iterable: Iterable[D], f: Callable[[L, D], L], initial: L, /
-) -> L | Never:
-    """Folds an iterable left with a function and initial value.
+def fold_left[D, L](
+        iterable: Iterable[D],
+        f: Callable[[L, D], L],
+        initial: L
+    ) -> L | Never:
+    """Fold an iterable left with a function and initial value.
 
-    - traditional FP type order given for function ``f``
-    - does not catch any exceptions ``f`` may raise
-    - like builtin ``sum`` for Python >=3.8 except
+    .. code:: python
+
+        def fold_left[D, L](
+            iterable: Iterable[D],
+            f: Callable[[L, D], L],
+            initial: L
+        ) -> L | Never
 
-      - not restricted to ``__add__`` for the folding function
-      - initial value required, does not default to ``0`` for initial value
-      - handles non-numeric data just find
+    - not restricted to ``__add__`` for the folding function
+    - initial value required, does not default to ``0`` for initial value
+    - handles non-numeric data just find
+
+    .. Warning::
+
+       This function never return if given an infinite iterable.
+
+    .. Warning::
+
+       This function does not catch any exceptions ``f`` may raise.
+
+    :param iterable: iterable to be folded
+    :param f: 2 parameter function, first parameter for accumulated value
+    :param initial: mandatory initial value to start fold
+    :return: the folded value
 
-    - never returns if ``iterable`` generates an infinite iterator
     """
     acc = initial
     for v in iterable:
@@ -332,15 +472,38 @@ def foldl[D, L](
     return acc
 
 
-def mb_fold_left[L, D](
-    iterable: Iterable[D], f: Callable[[L, D], L], initial: L | NoValue = NoValue()
-) -> MB[L]:
-    """Folds an iterable left with optional initial value.
+def maybe_fold_left[D, L](
+        iterable: Iterable[D],
+        f: Callable[[L, D], L],
+        initial: L | NoValue = NoValue()
+    ) -> MayBe[L] | Never:
+    """Folds an iterable left with an "optional" initial value..
+
+    .. code:: python
+
+        def maybe_fold_left[D, L](
+            iterable: Iterable[D],
+            f: Callable[[L, D], L],
+            initial: L
+        ) -> MayBe[L] | Never
 
     - traditional FP type order given for function ``f``
-    - when an initial value is not given then ``~L = ~D``
-    - if iterable empty and no ``initial`` value given, return ``MB()``
-    - never returns if iterable generates an infinite iterator
+    - when an initial value is not given then ``L = D``
+    - if iterable empty and no ``initial`` value given, return ``MayBe()``
+
+    .. Warning::
+
+       This function never return if given an infinite iterable.
+
+    .. Warning::
+
+       This function does not catch any exceptions ``f`` may raise.
+
+    :param iterable: The iterable to be folded.
+    :param f: First argument is for the accumulated value.
+    :param initial: Mandatory initial value to start fold.
+    :return: Folded value if it exists.
+
     """
     acc: L
     it = iter(iterable)
@@ -348,7 +511,7 @@ def mb_fold_left[L, D](
         try:
             acc = cast(L, next(it))  # in this case L = D
         except StopIteration:
-            return MB()
+            return MayBe()
     else:
         acc = cast(L, initial)
 
@@ -356,30 +519,48 @@ def mb_fold_left[L, D](
         try:
             acc = f(acc, v)
         except Exception:
-            return MB()
+            return MayBe()
 
-    return MB(acc)
+    return MayBe(acc)
 
 
 def sc_reduce_left[D](
-    iterable: Iterable[D],
-    f: Callable[[D, D], D],
-    /,
-    start: Callable[[D], bool] = (lambda d: True),
-    stop: Callable[[D], bool] = (lambda d: False),
-    include_start: bool = True,
-    include_stop: bool = True,
-) -> tuple[MB[D], Iterator[D]]:
-    """Short circuit version of a left reduce. Useful for infinite or iterables.
-
-    - Behavior for default arguments will
-
-      - left reduce finite iterable
-      - start folding immediately
-      - continue folding until end (of a possibly infinite iterable)
-
-    - Callable ``start`` delays starting the left reduce
-    - Callable ``stop`` prematurely stop the left reduce
+        iterable: Iterable[D],
+        f: Callable[[D, D], D],
+        start: Callable[[D], bool] = (lambda d: True),
+        stop: Callable[[D], bool] = (lambda d: False),
+        include_start: bool = True,
+        include_stop: bool = True,
+    ) -> tuple[MayBe[D], Iterator[D]]:
+    """Short circuit version of a left reduce.
+
+    .. code:: python
+
+        def sc_reduce_left[D](
+            iterable: Iterable[D],
+            f: Callable[[D, D], D],
+            start: Callable[[D], bool],
+            stop: Callable[[D], bool],
+            include_start: bool,
+            include_stop: bool
+        ) -> tuple[MayBe[D], Iterator[D]]
+
+    Useful for infinite iterables.
+
+    Behavior for default arguments will
+
+    - left reduce finite iterable
+    - start folding immediately
+    - continue folding until end (of a possibly infinite iterable)
+
+    :param iterable: iterable to be reduced from the left
+    :param f: 2 parameter function, first parameter for accumulated value
+    :param start: delay starting the fold until it returns true
+    :param stop: prematurely stop the fold when it returns true
+    :param include_start: if true, include fold starting value in fold
+    :param include_stop: if true, include stopping value in fold
+    :return: MayBe of the folded value and remaining iterables
+
     """
     it_start = drop_while(iterable, negate(start))
     if not include_start:
@@ -388,18 +569,18 @@ def sc_reduce_left[D](
         except StopIteration:
             pass
     it_reduce, it_rest = take_while_split(it_start, negate(stop))
-    mb_reduced = mb_fold_left(it_reduce, f)
+    mb_reduced = maybe_fold_left(it_reduce, f)
     if include_stop:
         if mb_reduced:
             try:
                 last = next(it_rest)
-                mb_reduced = MB(f(mb_reduced.get(), last))
+                mb_reduced = MayBe(f(mb_reduced.get(), last))
             except StopIteration:
                 pass
         else:
             try:
                 last = next(it_rest)
-                mb_reduced = MB(last)
+                mb_reduced = MayBe(last)
             except StopIteration:
                 pass
 
@@ -407,40 +588,57 @@ def sc_reduce_left[D](
 
 
 def sc_reduce_right[D](
-    iterable: Iterable[D],
-    f: Callable[[D, D], D],
-    /,
-    start: Callable[[D], bool] = (lambda d: False),
-    stop: Callable[[D], bool] = (lambda d: False),
-    include_start: bool = True,
-    include_stop: bool = True,
-) -> tuple[MB[D], Iterator[D]]:
-    """Short circuit version of a right reduce. Useful for infinite or
-    non-reversible iterables.
-
-    - Behavior for default arguments will
-
-      - right reduce finite iterable
-      - start reducing at end (of a possibly infinite iterable)
-      - continue reducing right until beginning
-
-    - Callable ``start`` prematurely starts the right reduce
-    - Callable ``stop`` prematurely stops the right reduce
+        iterable: Iterable[D],
+        f: Callable[[D, D], D],
+        start: Callable[[D], bool] = (lambda d: False),
+        stop: Callable[[D], bool] = (lambda d: False),
+        include_start: bool = True,
+        include_stop: bool = True,
+    ) -> tuple[MayBe[D], Iterator[D]]:
+    """Short circuit version of a right reduce.
+
+    .. code:: python
+
+        def sc_reduce_left[D](
+            iterable: Iterable[D],
+            f: Callable[[D, D], D],
+            start: Callable[[D], bool],
+            stop: Callable[[D], bool],
+            include_start: bool,
+            include_stop: bool
+        ) -> Tuple[MayBe[D] | Iterator[D]
+
+    Useful for infinite and non-reversible iterables.
+
+    Behavior for default arguments will
+
+    - right reduce finite iterable
+    - start folding at end (of a possibly infinite iterable)
+    - continue reducing right until beginning
+
+    :param iterable: iterable to be reduced from the right
+    :param f: 2 parameter function, second parameter for accumulated value
+    :param start: delay starting the fold until it returns true
+    :param stop: prematurely stop the fold when it returns true
+    :param include_start: if true, include fold starting value in fold
+    :param include_stop: if true, include stopping value in fold
+    :return: MayBe of the folded value and remaining iterables
+
     """
     it_start, it_rest = take_while_split(iterable, negate(start))
-    l1 = list(it_start)
+    list1 = list(it_start)
     if include_start:
         try:
             begin = next(it_rest)
         except StopIteration:
             pass
         else:
-            l1.append(begin)
+            list1.append(begin)
 
-    l1.reverse()
-    it_reduce, it_stop = take_while_split(l1, negate(stop))
+    list1.reverse()
+    it_reduce, it_stop = take_while_split(list1, negate(stop))
 
-    mb_reduced = mb_fold_left(it_reduce, swap(f))
+    mb_reduced = maybe_fold_left(it_reduce, swap(f))
     if include_stop:
         try:
             end = next(it_stop)
@@ -448,8 +646,8 @@ def sc_reduce_right[D](
             pass
         else:
             if mb_reduced:
-                mb_reduced = MB(f(end, mb_reduced.get()))
+                mb_reduced = MayBe(f(end, mb_reduced.get()))
             else:
-                mb_reduced = MB(end)
+                mb_reduced = MayBe(end)
 
     return (mb_reduced, it_rest)

{pythonic_fp_iterables-3.0.0.dist-info → pythonic_fp_iterables-4.0.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pythonic-fp.iterables
-Version: 3.0.0
-Summary: Module fp.iterables - Iterator related tools
+Version: 4.0.0
+Summary: Library of functions for iterating iterables.
 Keywords: iterables,iterators
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
 Requires-Python: >=3.12
@@ -17,8 +17,8 @@ License-File: LICENSE
 Requires-Dist: pythonic-fp.circulararray>=5.0.0
 Requires-Dist: pythonic-fp.containers >=2.0.0
 Requires-Dist: pythonic-fp.fptools >=3.0.0
-Project-URL: Changelog, https://grscheller.github.io/pythonic-fp-iterables/html/changelog.html
-Project-URL: Documentation, https://grscheller.github.io/pythonic-fp-iterables/html/
+Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-iterables/blob/main/CHANGELOG.rst
+Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/iterables/API/development/build/html/releases.html
 Project-URL: Homepage, https://github.com/grscheller/pythonic-fp/blob/main/README.md
 Project-URL: Source, https://github.com/grscheller/pythonic-fp-iterables
 
@@ -26,24 +26,29 @@ Project-URL: Source, https://github.com/grscheller/pythonic-fp-iterables
 
 PyPI project
 [pythonic-fp.iterators](https://pypi.org/project/pythonic-fp.iterables/)
-implementing a Python package of tools for iterables and iterators.
+implementing a Python library of functions for iterables and iterators.
 
 - Concatenating and merging iterables
 - Dropping and taking values from iterables
 - Reducing and accumulating iterables
-- Assumptions
-  - iterables are not necessarily iterators
-  - at all times iterator protocol is assumed to be followed
-    - all iterators are assumed to be iterable
-    - for all iterators `my_iter` we assume `iter(my_iter) is my_iter`
+
+#### Info:
+
+This library assumes that at all times iterator protocol
+is followed. This means that all iterators are iterable and
+that ``iter(some_iterator) is some_iterator``.
+
+#### Note:
+
+Iterables are not necessarily iterators.
 
 This PyPI project is part of of the grscheller
 [pythonic-fp namespace projects](https://github.com/grscheller/pythonic-fp/blob/main/README.md).
 
 ## Documentation
 
-Documentation hosted on
-[GitHub Pages](https://grscheller.github.io/pythonic-fp-iterables/html).
+Documentation for this PyPI projects is hosted on
+[GitHub Pages](https://grscheller.github.io/pythonic-fp/iterators/API/development/build/html/releases.html).
 
 ## Copyright and License
 

pythonic_fp_iterables-4.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+pythonic_fp/iterables.py,sha256=PMAE7J3GWFtOqVmIlquPprP584wxMnblO3AJxaI3WAQ,18186
+pythonic_fp_iterables-4.0.0.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
+pythonic_fp_iterables-4.0.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pythonic_fp_iterables-4.0.0.dist-info/METADATA,sha256=vOvNgxdVrs0JBSf3dSA8NaHZXiW_LEVNZ8LR51r7fUQ,2160
+pythonic_fp_iterables-4.0.0.dist-info/RECORD,,

pythonic_fp_iterables-3.0.0.dist-info/RECORD

@@ -1,5 +0,0 @@
-pythonic_fp/iterables.py,sha256=Si4a4JcJhrStvpxqe8msaqiskcgrb3D8xJP2oN-6VG8,13194
-pythonic_fp_iterables-3.0.0.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
-pythonic_fp_iterables-3.0.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pythonic_fp_iterables-3.0.0.dist-info/METADATA,sha256=9vZd4-jSvYbAXdXXSo6UwZHcLgrSEprn2J6cgyqUkeA,2059
-pythonic_fp_iterables-3.0.0.dist-info/RECORD,,