pythonic-fp.iterables 5.1.3__py3-none-any.whl → 5.2.0__py3-none-any.whl

pythonic_fp/iterables/__init__.py

@@ -13,20 +13,11 @@
 # limitations under the License.
 
 """
-Tools for iterables
--------------------
+.. admonition:: Composing and iterating iterables
 
-.. admonition:: Library of functions for iterating iterables
-
-    +-----------+-------------------------------------------+
-    | Module    | Description                               |
-    +===========+===========================================+
-    | merging   | Concatenating and merging iterables       |
-    +-----------+-------------------------------------------+
-    | drop_take | Dropping and taking values from iterables |
-    +-----------+-------------------------------------------+
-    | folding   | Reducing and accumulating iterables       |
-    +-----------+-------------------------------------------+
+    - module **merging:** Concatenating and merging iterables.
+    - module **drop_take:** Dropping and taking values from iterables.
+    - module **folding:**  Reducing and accumulating iterables.
 
 .. important::
 
@@ -35,8 +26,8 @@ Tools for iterables
     - 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 ``foobar`` we assume ``iter(foobar) is foobar``
+      - all iterators are assumed to be iterable
+      - for all iterators ``foo`` we assume ``iter(foo) is foo``
 
 """
 

pythonic_fp/iterables/drop_take.py

@@ -1,4 +1,4 @@
-# Copyright 2023-2025 Geoffrey R. Scheller
+# Copyright 2023-2026 Geoffrey R. Scheller
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,12 +13,23 @@
 # limitations under the License.
 
 """
-Drop and Take
--------------
+.. admonition:: Drop and Take
 
-.. admonition:: module pythonic_fp.iterables.drop_take
+    Functions which drop or take items from an iterable.
 
-    Functions to drop or take values from an iterable.
+    .. important::
+
+        If iterable is a multiply referenced iterator, items
+        dropped or taken need not be the next consecutive items.
+
+    .. important::
+
+        If iterable is mutable, iterator may be affected by the
+        current state of the original iterable.
+
+        .. tip::
+
+            Prefer immutable iterables over mutable ones.
 
 """
 
@@ -37,11 +48,14 @@ __all__ = [
 
 
 def drop[D](iterable: Iterable[D], n: int) -> Iterator[D]:
-    """Drop the next n values from iterable.
+    """
+    .. admonition:: drop
+
+        Drop the next n items from iterable.
 
-    :param iterable: Iterable whose values are to be dropped.
-    :param n: Number of values to be dropped.
-    :returns: An iterator of the remaining values.
+        :param iterable: Iterable whose items are to be dropped.
+        :param n: Number of items to be dropped.
+        :yields: The remaining items.
 
     """
     iterator = iter(iterable)
@@ -54,19 +68,22 @@ def drop[D](iterable: Iterable[D], n: int) -> Iterator[D]:
 
 
 def drop_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[D]:
-    """Drop initial values from iterable while predicate is true.
+    """
+    .. admonition:: drop while
+
+        Drop initial items from iterable while predicate is true.
 
-    :param iterable: Iterable whose values are to be dropped.
-    :param pred: Single argument Boolean valued function, the "predicate".
-    :returns: An iterator beginning where pred returned false.
+        :param iterable: Iterable whose items are to be dropped.
+        :param pred: Single argument Boolean valued function.
+        :yields: items starting when ``pred`` returns ``False``.
 
     """
     iterator = iter(iterable)
     while True:
         try:
-            value = next(iterator)
-            if not pred(value):
-                iterator = concat((value,), iterator)
+            item = next(iterator)
+            if not pred(item):
+                iterator = concat((item,), iterator)
                 break
         except StopIteration:
             break
@@ -74,40 +91,46 @@ def drop_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[
 
 
 def take[D](iterable: Iterable[D], n: int) -> Iterator[D]:
-    """Return an iterator of up to n initial values of an iterable.
+    """
+    .. admonition:: take
+
+        Return an iterator yielding up to n items from an iterable.
 
-    :param Iterable: iterable providing the values to be taken.
-    :param n: Number of values to be dropped.
-    :returns: An iterator of up to n initial values from iterable.
+        :param Iterable: Iterable providing the items to be taken.
+        :param n: Number of items to be taken.
+        :yields: Up to n items from iterable.
 
     """
     iterator = iter(iterable)
     for _ in range(n):
         try:
-            value = next(iterator)
-            yield value
+            item = next(iterator)
+            yield item
         except StopIteration:
             break
 
 
 def take_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[D]:
-    """Yield values from iterable while predicate is true.
+    """
+    .. admonition:: take while
+
+        Return an iterator of items until predicate false.
 
-    .. warning::
+        :param iterable: Iterable providing the items to be taken.
+        :param pred: Single argument Boolean valued function.
+        :yields: Items from iterable while predicate is true.
 
-        Risk of value loss if iterable is multiple referenced iterator.
+        .. warning::
 
-    :param iterable: Iterable providing the values to be taken.
-    :param pred: Single argument Boolean valued function, the "predicate".
-    :returns: An Iterator of of values from iterable until predicate false.
+            Risk of data loss if iterable is multiple referenced iterator.
 
     """
     iterator = iter(iterable)
     while True:
         try:
-            value = next(iterator)
-            if pred(value):
-                yield value
+            item = next(iterator)
+            if pred(item):
+                yield item
             else:
                 break
         except StopIteration:
@@ -115,16 +138,21 @@ def take_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[
 
 
 def take_split[D](iterable: Iterable[D], n: int) -> tuple[Iterator[D], Iterator[D]]:
-    """Same as take except also return iterator of remaining values.
+    """
+    .. admonition:: take split
+
+        Same as take except also return an iterator of
+        the remaining items.
 
-    .. Warning::
+        .. admonition:: CONTRACT
 
-        **CONTRACT:** Do not access the second returned iterator until the
-        first one is exhausted.
+            **IMPORTANT:** Do not access the second iterator until
+            the first one is completely exhausted.
 
-    :param iterable: Iterable providing the values to be taken.
-    :param n: maximum Number of values to be taken.
-    :returns: An iterator of values taken and an iterator of remaining values.
+        :param iterable: Iterable providing the items to be taken.
+        :param n: maximum Number of items to be taken.
+        :returns: A tuple containing an iterator of items taken
+                  and an iterator of remaining items.
 
     """
     iterator = iter(iterable)
@@ -136,16 +164,21 @@ def take_split[D](iterable: Iterable[D], n: int) -> tuple[Iterator[D], Iterator[
 def take_while_split[D](
     iterable: Iterable[D], pred: Callable[[D], bool]
 ) -> tuple[Iterator[D], Iterator[D]]:
-    """Yield values from iterable while predicate is true.
+    """
+    .. admonition:: take while
+
+        Same as take_while except also return an iterator of
+        the remaining items.
 
-    .. Warning::
+        .. admonition:: CONTRACT
 
-        **CONTRACT:** Do not access the second returned iterator until
-        the first one is exhausted.
+            **IMPORTANT:** Do not access the second iterator until
+            the first one is completely exhausted.
 
-    :param iterable: Iterable providing the values to be taken.
-    :param pred: Single argument Boolean valued function.
-    :returns: Tuple of iterator of values taken and an iterator of remaining values.
+        :param iterable: Iterable providing the items to be taken.
+        :param pred: Single argument Boolean valued function.
+        :returns: A tuple containing an iterator of items taken while
+                  ``pred`` truthy and an iterator of remaining items.
 
     """
 
@@ -163,7 +196,7 @@ def take_while_split[D](
                 break
 
     iterator = iter(iterable)
-    value: Box[D] = Box()
-    it_pred = _take_while(iterator, pred, value)
+    item: Box[D] = Box()
+    it_pred = _take_while(iterator, pred, item)
 
-    return it_pred, concat(value, iterator)
+    return it_pred, concat(item, iterator)

pythonic_fp/iterables/folding.py

@@ -1,4 +1,4 @@
-# Copyright 2023-2025 Geoffrey R. Scheller
+# Copyright 2023-2026 Geoffrey R. Scheller
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,12 +13,9 @@
 # limitations under the License.
 
 """
-Folding
--------
+.. admonition:: Folding and Accumulating
 
-.. admonition:: module pythonic_fp.iterables.folding
-
-    Functions to reduce and accumulate values from iterables.
+    Functions to reduce and accumulate items from iterables.
 
 """
 
@@ -42,17 +39,24 @@ __all__ = [
 def accumulate[D, L](
     iterable: Iterable[D], f: Callable[[L, D], L], initial: L | NoValue = NoValue()
 ) -> Iterator[L]:
-    """Returns an iterator of partial fold values.
+    """
+    .. admonition:: accumulate
+
+        Returns an iterator of partially folded items.
 
-    A pure Python version of standard library's ``itertools.accumulate``
+        :param iterable: Iterable to be folded.
+        :param f: Two parameter function, first parameter is for
+                  the accumulator.
+        :param initial: Optional ``initial`` item to start fold.
+        :yields: The intermediate folded items.
 
-    - function ``f`` does not default to addition (for typing flexibility)
-    - begins accumulation with an "optional" ``initial`` value
+        .. note::
 
-    :param iterable: iterable to be folded
-    :param f: two parameter function, first parameter for accumulated value
-    :param initial: "optional" initial value to start fold
-    :return: an iterator of the intermediate fold values
+            A pure Python implementation of the standard
+            library's ``itertools.accumulate``
+
+            - function ``f`` does not default to addition (for typing flexibility)
+            - begins accumulation with an optional ``initial`` item
 
     """
     it = iter(iterable)
@@ -80,21 +84,22 @@ def accumulate[D, L](
 
 
 def reduce_left[D](iterable: Iterable[D], f: Callable[[D, D], D]) -> D | Never:
-    """Fold an iterable left with a function.
-
-    .. Warning::
+    """
+    .. admonition:: reduce left
 
-       This function never return if given an infinite iterable.
+        Fold an iterable left with a function.
 
-    .. Warning::
+        :param iterable: Iterable to be reduced (folded).
+        :param f: Two parameter function, first parameter is for
+                  the accumulator.
+        :return: Reduced item from the iterable.
+        :raises StopIteration: When called on an empty iterable.
+        :raises Exception: Does not catch any exceptions from ``f``.
 
-       This function does not catch or re-raises exceptions from ``f``.
+        .. warning::
 
-    :param iterable: iterable to be reduced (folded)
-    :param f: two parameter function, first parameter for accumulated value
-    :return: reduced value from the iterable
-    :raises StopIteration: when called on an empty iterable
-    :raises Exception: does not catch any exceptions from ``f``
+            - never returns if given an infinite iterable
+            - does not catch or re-raise exceptions raised by ``f``
 
     """
     it = iter(iterable)
@@ -113,24 +118,25 @@ def reduce_left[D](iterable: Iterable[D], f: Callable[[D, D], D]) -> D | Never:
 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.
-
-    - 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
+    """
+    .. admonition:: fold left
 
-    .. Warning::
+        Fold an iterable left with a function and initial item.
 
-       This function never return if given an infinite iterable.
+        - not restricted to ``__add__`` for the folding function
+        - initial item is required, does not default to ``0``
+        - handles non-numeric data just find
 
-    .. Warning::
+        :param iterable: Iterable to be folded.
+        :param f: Two parameter function, first parameter is for
+                  the accumulator.
+        :param initial: Mandatory initial item to start fold
+        :return: The folded item.
 
-       This function does not catch any exceptions ``f`` may raise.
+        .. warning::
 
-    :param iterable: iterable to be folded
-    :param f: two parameter function, first parameter for accumulated value
-    :param initial: mandatory initial value to start fold
-    :return: the folded value
+            - never returns if given an infinite iterable
+            - does not catch or re-raises exceptions raised by ``f``
 
     """
     acc = initial
@@ -142,24 +148,24 @@ def fold_left[D, L](
 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..
-
-    - when an initial value is not given then ``L = D``
-    - if iterable empty and no ``initial`` value given, return ``MayBe()``
+    """
+    .. admonition:: maybe fold left
 
-    .. Warning::
+        Folds an iterable left with an "optional" initial item.
 
-       This function never return if given an infinite iterable.
+        - when an initial item is not given then ``L = D``
+        - if iterable empty and no ``initial`` item given, return ``MayBe()``
 
-    .. Warning::
+        :param iterable: The iterable to be folded.
+        :param f: First argument is for the accumulator.
+        :param initial: Mandatory initial item to start fold.
+        :return: ``MayBe`` of a successfully folded item,
+                 otherwise returns ``MayBe()``.
 
-        This function returns a ``MayBe()`` when ``f`` raises any
-        exception what-so-ever. The exception is thrown away.
+        .. warning::
 
-    :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: MayBe of a successfully folded value, otherwise MayBe()
+            - never returns if given an infinite iterable
+            - any exception ``f`` raises is thrown away
 
     """
     acc: L
@@ -189,23 +195,33 @@ def sc_reduce_left[D](
     include_start: bool = True,
     include_stop: bool = True,
 ) -> tuple[MayBe[D], Iterator[D]]:
-    """Short circuit version of a left reduce.
+    """
+    .. admonition:: short circuit reduce left
+
+        Short circuit version of a left fold.
+
+        :param iterable: Iterable to be reduced from the left.
+        :param f: Two parameter function, first parameter is for
+                  the accumulator.
+        :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 starting item in fold.
+        :param include_stop: If true, include stopping item in fold.
+        :return: Tuple of a ``MayBe`` of the folded item and iterator
+                 of remaining iterables.
+
+        .. note::
 
-    Useful for infinite iterables.
+            Behavior for default arguments will
 
-    Behavior for default arguments will
+            - left reduce finite iterable
+            - start folding immediately
+            - continue folding until end (of a possibly infinite iterable)
 
-    - left reduce finite iterable
-    - start folding immediately
-    - continue folding until end (of a possibly infinite iterable)
+            .. tip::
 
-    :param iterable: iterable to be reduced from the left
-    :param f: two 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: tuple of a MayBe of the folded value and iterator of remaining iterables
+                Useful for infinite iterables when Callable ``stop``
+                is provided.
 
     """
     it_start = drop_while(iterable, negate(start))
@@ -241,23 +257,32 @@ def sc_reduce_right[D](
     include_start: bool = True,
     include_stop: bool = True,
 ) -> tuple[MayBe[D], Iterator[D]]:
-    """Short circuit version of a right reduce.
+    """
+    .. admonition:: short circuit reduce right
+
+        Short circuit version of a right fold.
+
+        :param iterable: Iterable to be reduced from the right.
+        :param f: Two parameter function, second parameter is for
+                  the accumulator.
+        :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 starting item.
+        :param include_stop: If true, include stopping item in fold.
+        :return: Tuple of a ``MayBe`` of the folded item and iterator
+                 of remaining iterables.
+
+        .. note::
 
-    Useful for infinite and non-reversible iterables.
+            Behavior for default arguments will
 
-    Behavior for default arguments will
+            - right reduce finite iterable
+            - start folding at end (of a possibly infinite iterable)
+            - continue reducing right until beginning
 
-    - right reduce finite iterable
-    - start folding at end (of a possibly infinite iterable)
-    - continue reducing right until beginning
+            .. tip::
 
-    :param iterable: iterable to be reduced from the right
-    :param f: two 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: tuple of a MayBe of the folded value and iterator of remaining iterables
+                Useful for infinite and non-reversible iterables.
 
     """
     it_start, it_rest = take_while_split(iterable, negate(start))

pythonic_fp/iterables/merging.py

@@ -1,4 +1,4 @@
-# Copyright 2023-2025 Geoffrey R. Scheller
+# Copyright 2023-2026 Geoffrey R. Scheller
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,10 +13,7 @@
 # limitations under the License.
 
 """
-Merging Iterables
------------------
-
-.. admonition:: module pythonic_fp.iterables.merging
+.. admonition:: Merging iterables
 
     Functions to merge multiple iterables together into one.
 
@@ -35,98 +32,112 @@ __all__ = [
 
 
 class MergeEnum(Enum):
-    """Iterable Blending Enums.
+    """
+    .. admonition:: Iterable Blending Enums.
 
-    - **MergeEnum.Concat:** Concatenate first to last
-    - **MergeEnum.Merge:** Merge until one is exhausted
-    - **MergeEnum.Exhaust:** Merge until all are exhausted
+        - **Concat:** Concatenate first to last
+        - **Merge:** Merge until one is exhausted
+        - **Exhaust:** Merge until all are exhausted
 
     """
-
     Concat = auto()
     Merge = auto()
     Exhaust = auto()
 
 
 def concat[D](*iterables: Iterable[D]) -> Iterator[D]:
-    """Sequentially concatenate multiple iterables together.
+    """
+    .. admonition:: concatenate iterables
 
-    .. warning::
-        An infinite iterable will prevent subsequent iterables from
-        yielding any values.
+        Sequentially concatenate multiple iterables.
 
-    .. note::
+        :param iterables: Iterables to concatenate.
+        :yields: The concatenated items from all the iterables.
 
-        Performant to the standard library's ``itertools.chain``.
+        .. warning::
+            An infinite iterable will prevent subsequent iterables from
+            yielding any items.
 
-    :param iterables: Iterables to concatenate.
-    :returns: Iterator of concatenated values from the iterables.
+        .. note::
+
+            Performant to the standard library's ``itertools.chain``.
 
     """
     for iterator in map(lambda x: iter(x), iterables):
         while True:
             try:
-                value = next(iterator)
-                yield value
+                item = next(iterator)
+                yield item
             except StopIteration:
                 break
 
 
 def merge[D](*iterables: Iterable[D], yield_partials: bool = False) -> Iterator[D]:
-    """Merge together ``iterables`` until one is exhausted.
+    """
+    .. admonition:: merge iterables
+
+        Merge multiple iterables until one of them is exhausted.
 
-    .. note::
+        :param iterables: Iterables to merge until one gets exhausted.
+        :param yield_partials: Yield any unpaired yielded items from other iterables.
+        :yields: Merged items from the iterables until one of the
+                 iterables is exhausted.
 
-        When ``yield_partials`` is true, then any unmatched values from other iterables
-        already yielded when the first iterable is exhausted are yielded. This prevents
-        data lose if any of the iterables are iterators with external references.
+        .. note::
 
-    :param iterables: Iterables to merge until one gets exhausted.
-    :param yield_partials: Yield any unpaired yielded values from other iterables.
-    :returns: Iterator of merged values from the iterables until one is exhausted.
+            When ``yield_partials`` is true, then any unmatched items
+            from other iterables already yielded when the first iterable
+            is exhausted are yielded.
+
+            This prevents data lose if any of the iterables are
+            iterators with external references.
 
     """
     iter_list = list(map(lambda x: iter(x), iterables))
-    values = []
+    items = []
     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()
+                    items.append(next(iter_list[ii]))
+                yield from items
+                items.clear()
             except StopIteration:
                 break
         if yield_partials:
-            yield from values
+            yield from items
 
 
 def exhaust[D](*iterables: Iterable[D]) -> Iterator[D]:
-    """Merge together multiple iterables until all are exhausted.
+    """
+    .. admonition:: exhaustively merge iterables
+
+        Merge multiple iterables until all of them are exhausted.
 
-    :param iterables: Iterables to exhaustively merge.
-    :returns: Iterator of merged values from the iterables until all are exhausted.
+        :param iterables: Iterables to exhaustively merge.
+        :yields: Merged items from the iterables until all of the
+                 iterables are exhausted.
 
     """
     iter_list = list(map(lambda x: iter(x), iterables))
     if (num_iters := len(iter_list)) > 0:
         ii = 0
-        values = []
+        items = []
         while True:
             try:
                 while ii < num_iters:
-                    values.append(next(iter_list[ii]))
+                    items.append(next(iter_list[ii]))
                     ii += 1
-                yield from values
+                yield from items
                 ii = 0
-                values.clear()
+                items.clear()
             except StopIteration:
                 num_iters -= 1
                 if num_iters < 1:
                     break
                 del iter_list[ii]
 
-        yield from values
+        yield from items
 
 
 def blend[D](
@@ -134,13 +145,20 @@ def blend[D](
     merge_enum: MergeEnum = MergeEnum.Concat,
     yield_partials: bool = False,
 ) -> Iterator[D]:
-    """Merge behavior based on value of merge_enum parameter.
+    """
+    .. admonition:: merge iterables
+
+        Merge behavior based on value of merge_enum parameter.
+
+        - Concat: Concatenate first to last
+        - Merge: Merge until one is exhausted
+        - Exhaust: Merge until all are exhausted
 
-    :param iterables: Iterables to blend together.
-    :param merge_enum: ``MergeEnum`` to determine merging behavior.
-    :param yield_partials: Yield unpaired values from other iterables.
-    :returns: An iterator of type ``D``.
-    :raises ValueError: When an unknown ``MergeEnum`` is given.
+        :param iterables: Iterables to blend together.
+        :param merge_enum: ``MergeEnum`` to determine merging behavior.
+        :param yield_partials: Yield unpaired items from other iterables.
+        :yields: Items from all iterables blended together.
+        :raises ValueError: When an unknown ``MergeEnum`` is given.
 
     """
     match merge_enum:

{pythonic_fp_iterables-5.1.3.dist-info → pythonic_fp_iterables-5.2.0.dist-info}/METADATA

@@ -1,62 +1,53 @@
 Metadata-Version: 2.4
 Name: pythonic-fp-iterables
-Version: 5.1.3
-Summary: Tools for iterables
+Version: 5.2.0
+Summary: Composing and iterating iterables.
 Keywords: iterables,iterators
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
-Requires-Python: >=3.13
-Description-Content-Type: text/x-rst
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: pythonic-fp-fptools>=5.2.0
-Requires-Dist: pythonic-fp-gadgets>=4.0.2
-Requires-Dist: pytest>=8.4.1 ; extra == "test"
-Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-iterables/blob/main/CHANGELOG.rst
-Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/iterables/development/build/html/
-Project-URL: Homepage, https://grscheller.github.io/pythonic-fp/homepage/build/html/
+Requires-Dist: pythonic-fp-fptools>=6,<6.2
+Requires-Dist: pythonic-fp-gadgets>=4.5,<6
+Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-iterables/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://grscheller.github.io/pythonic-fp-iterables/release/html/
+Project-URL: Homepage, https://grscheller.github.io/pythonic-fp/
 Project-URL: Source, https://github.com/grscheller/pythonic-fp-iterables
-Provides-Extra: test
 
-Pythonic FP - Tools for iterables
-=================================
+# Pythonic FP - Tools for iterables
+
+Library of functions for iterating iterables.
 
 PyPI project
-`pythonic-fp.iterators <https://pypi.org/project/pythonic-fp.iterables>`_.
+[pythonic-fp-iterators](https://pypi.org/project/pythonic-fp-iterables).
+Part of the
+[pythonic-fp](https://grscheller.github.io/pythonic-fp/)
+PyPI projects.
 
-Library of functions for iterating iterables.
+## Documentation
+
+Documentation and other links for this project are hosted on
+[GitHub Pages](https://grscheller.github.io/pythonic-fp/projects/iterables.html).
 
 - 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 ``foo`` we assume ``iter(foo) is foo``
 
-Part of the
-`pythonic-fp
-<https://grscheller.github.io/pythonic-fp>`_
-PyPI projects.
-
-Documentation
--------------
-
-Documentation for this project is hosted on
-`GitHub Pages
-<https://grscheller.github.io/pythonic-fp/iterables>`_.
-
-Copyright and License
----------------------
+## Copyright and License
 
-Copyright (c) 2023-2025 Geoffrey R. Scheller. Licensed under the Apache
+Copyright (c) 2023-2026 Geoffrey R. Scheller. Licensed under the Apache
 License, Version 2.0. See the LICENSE file for details.
 

pythonic_fp_iterables-5.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pythonic_fp/iterables/__init__.py,sha256=lL6SETAAn9sn2dGRBxvbJlswZwweym4OumCKbJfokQI,1246
+pythonic_fp/iterables/drop_take.py,sha256=kZS8paCc-EOD42BGmCg-89e0W9CGFCXiB88Y4oE_lSg,5527
+pythonic_fp/iterables/folding.py,sha256=IZmoWyuh8D9rS_g9K8DhSu_owM1_IJ_oIMsLJNqH28I,9377
+pythonic_fp/iterables/merging.py,sha256=YYXrCNXHF9xuIMLOySTube6-_YUNB2GGirTa8VbpeLM,5038
+pythonic_fp/iterables/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonic_fp_iterables-5.2.0.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
+pythonic_fp_iterables-5.2.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pythonic_fp_iterables-5.2.0.dist-info/METADATA,sha256=yajE7AFhbVcOksI_nW2PdhDdURZjrRkRlpBfBAfiVdw,1997
+pythonic_fp_iterables-5.2.0.dist-info/RECORD,,

pythonic_fp/iterables/drop_take.pyi

@@ -1,10 +0,0 @@
-from collections.abc import Callable, Iterable, Iterator
-
-__all__ = ['drop', 'drop_while', 'take', 'take_while', 'take_split', 'take_while_split']
-
-def drop[D](iterable: Iterable[D], n: int) -> Iterator[D]: ...
-def drop_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[D]: ...
-def take[D](iterable: Iterable[D], n: int) -> Iterator[D]: ...
-def take_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[D]: ...
-def take_split[D](iterable: Iterable[D], n: int) -> tuple[Iterator[D], Iterator[D]]: ...
-def take_while_split[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> tuple[Iterator[D], Iterator[D]]: ...

pythonic_fp/iterables/folding.pyi

@@ -1,13 +0,0 @@
-from collections.abc import Callable, Iterable, Iterator
-from pythonic_fp.fptools.maybe import MayBe
-from pythonic_fp.gadgets.sentinels.novalue import NoValue
-from typing import Never
-
-__all__ = ['accumulate', 'reduce_left', 'fold_left', 'maybe_fold_left', 'sc_reduce_left', 'sc_reduce_right']
-
-def accumulate[D, L](iterable: Iterable[D], f: Callable[[L, D], L], initial: L | NoValue = ...) -> Iterator[L]: ...
-def reduce_left[D](iterable: Iterable[D], f: Callable[[D, D], D]) -> D | Never: ...
-def fold_left[D, L](iterable: Iterable[D], f: Callable[[L, D], L], initial: L) -> L | Never: ...
-def maybe_fold_left[D, L](iterable: Iterable[D], f: Callable[[L, D], L], initial: L | NoValue = ...) -> MayBe[L] | Never: ...
-def sc_reduce_left[D](iterable: Iterable[D], f: Callable[[D, D], D], start: Callable[[D], bool] = ..., stop: Callable[[D], bool] = ..., include_start: bool = True, include_stop: bool = True) -> tuple[MayBe[D], Iterator[D]]: ...
-def sc_reduce_right[D](iterable: Iterable[D], f: Callable[[D, D], D], start: Callable[[D], bool] = ..., stop: Callable[[D], bool] = ..., include_start: bool = True, include_stop: bool = True) -> tuple[MayBe[D], Iterator[D]]: ...

pythonic_fp/iterables/merging.pyi

@@ -1,14 +0,0 @@
-from collections.abc import Iterable, Iterator
-from enum import Enum
-
-__all__ = ['MergeEnum', 'concat', 'merge', 'exhaust', 'blend']
-
-class MergeEnum(Enum):
-    Concat = ...
-    Merge = ...
-    Exhaust = ...
-
-def concat[D](*iterables: Iterable[D]) -> Iterator[D]: ...
-def merge[D](*iterables: Iterable[D], yield_partials: bool = False) -> Iterator[D]: ...
-def exhaust[D](*iterables: Iterable[D]) -> Iterator[D]: ...
-def blend[D](*iterables: Iterable[D], merge_enum: MergeEnum = ..., yield_partials: bool = False) -> Iterator[D]: ...

pythonic_fp_iterables-5.1.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-pythonic_fp/iterables/__init__.py,sha256=oAoufgaFeHBH81d-ey738bBsVSximbrp0Rseb3EafnI,1663
-pythonic_fp/iterables/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pythonic_fp/iterables/drop_take.py,sha256=Kvj-B_xXD9t4tsIjMRdMXwSDKAeUsfbtLPs6X7wRapg,4847
-pythonic_fp/iterables/drop_take.pyi,sha256=vPyByY4PxCGEuL6trI0aTK8fBr4xCuOgqhaKALwJ5Ys,653
-pythonic_fp/iterables/folding.py,sha256=5-EJT-lp8EhAghMlNghla3rnVL0ywRS3-kGuO13oEVI,8711
-pythonic_fp/iterables/folding.pyi,sha256=ZVrpB-D4kWoVwpCsQ2rc3GJ8iTzavAOQ5YK9LteAukU,1175
-pythonic_fp/iterables/merging.py,sha256=mJ4nmIxSwuoi8LvYTHbU-JEUqkii1BdociRs59Dxq-A,4613
-pythonic_fp/iterables/merging.pyi,sha256=KnuSFREXEpnbtTvMWsvn-KfeSjZ3ybP-6n9hCxjNKVs,533
-pythonic_fp/iterables/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pythonic_fp_iterables-5.1.3.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
-pythonic_fp_iterables-5.1.3.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pythonic_fp_iterables-5.1.3.dist-info/METADATA,sha256=Mi8wDsA-nnmMXWfrhS42W1CULGDYOcsSRqTk1nxNJNo,2064
-pythonic_fp_iterables-5.1.3.dist-info/RECORD,,