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

pythonic_fp/iterables/__init__.py

@@ -0,0 +1,42 @@
+# Copyright 2023-2024 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+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       |
++-----------+-------------------------------------------+
+
+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 ``foobar`` we assume ``iter(foobar) is foobar``
+
+"""
+
+__author__ = 'Geoffrey R. Scheller'
+__copyright__ = 'Copyright (c) 2023-2025 Geoffrey R. Scheller'
+__license__ = 'Apache License 2.0'

pythonic_fp/iterables/drop_take.py

@@ -0,0 +1,165 @@
+# Copyright 2023-2025 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Module pythonic_fp.iterables.drop_take
+"""
+
+from collections.abc import Callable, Iterable, Iterator
+from pythonic_fp.gadgets.box import Box
+from .merging import concat
+
+__all__ = [
+    'drop',
+    'drop_while',
+    'take',
+    'take_while',
+    'take_split',
+    'take_while_split',
+]
+
+
+## dropping and taking
+
+
+def drop[D](iterable: Iterable[D], n: int) -> Iterator[D]:
+    """Drop the next n values 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
+
+    """
+    iterator = iter(iterable)
+    for _ in range(n):
+        try:
+            next(iterator)
+        except StopIteration:
+            break
+    return iterator
+
+
+def drop_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[D]:
+    """Drop initial values from iterable while predicate is true.
+
+    :param iterable: iterable whose values are to be dropped
+    :param pred: Boolean valued function, the "predicate"
+    :return: an iterator beginning where pred returned false
+
+    """
+    iterator = iter(iterable)
+    while True:
+        try:
+            value = next(iterator)
+            if not pred(value):
+                iterator = concat((value,), iterator)
+                break
+        except StopIteration:
+            break
+    return iterator
+
+
+def take[D](iterable: Iterable[D], n: int) -> Iterator[D]:
+    """Return an iterator of up to n initial values of an iterable.
+
+    :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
+
+    """
+    iterator = iter(iterable)
+    for _ in range(n):
+        try:
+            value = next(iterator)
+            yield value
+        except StopIteration:
+            break
+
+
+def take_while[D](iterable: Iterable[D], pred: Callable[[D], bool]) -> Iterator[D]:
+    """Yield values from iterable while predicate is true.
+
+    .. 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, the "predicate"
+    :return: an Iterator of of values from iterable until predicate false
+
+    """
+    iterator = iter(iterable)
+    while True:
+        try:
+            value = next(iterator)
+            if pred(value):
+                yield value
+            else:
+                break
+        except StopIteration:
+            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.
+
+    .. 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
+
+    """
+    iterator = iter(iterable)
+    itn = take(iterator, n)
+
+    return itn, 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.
+
+    .. 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: tuple containing an iterator of values taken and an iterator of remaining values
+
+    """
+
+    def _take_while(
+        iterator: Iterator[D], pred: Callable[[D], bool], val: Box[D]
+    ) -> Iterator[D]:
+        while True:
+            try:
+                val.put(next(iterator))
+                if pred(val.get()):
+                    yield val.pop()
+                else:
+                    break
+            except StopIteration:
+                break
+
+    iterator = iter(iterable)
+    value: Box[D] = Box()
+    it_pred = _take_while(iterator, pred, value)
+
+    return (it_pred, concat(value, iterator))

pythonic_fp/iterables/drop_take.pyi

@@ -0,0 +1,33 @@
+# Copyright 2023-2025 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+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.py

@@ -0,0 +1,280 @@
+# Copyright 2023-2025 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Module pythonic_fp.iterables.folding"""
+
+from collections.abc import Callable, Iterable, Iterator
+from typing import cast, Never
+from pythonic_fp.fptools.function import negate, swap
+from pythonic_fp.fptools.maybe import MayBe
+from pythonic_fp.sentinels.novalue import NoValue
+from .drop_take import drop_while, take_while_split
+
+__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 = NoValue()
+) -> Iterator[L]:
+    """Returns an iterator of partial fold values.
+
+    A 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
+
+    :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
+
+    """
+    it = iter(iterable)
+    try:
+        it0 = next(it)
+    except StopIteration:
+        if initial is NoValue():
+            return
+        yield cast(L, initial)
+    else:
+        if initial is not NoValue():
+            init = cast(L, initial)
+            yield init
+            acc = f(init, it0)
+            for ii in it:
+                yield acc
+                acc = f(acc, ii)
+            yield acc
+        else:
+            acc = cast(L, it0)  # in this case L = D
+            for ii in it:
+                yield acc
+                acc = f(acc, ii)
+            yield acc
+
+
+def reduce_left[D](iterable: Iterable[D], f: Callable[[D, D], D]) -> D | Never:
+    """Fold an iterable left with a function.
+
+    .. 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: 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``
+
+    """
+    it = iter(iterable)
+    try:
+        acc = next(it)
+    except StopIteration as exc:
+        msg = 'Attempt to reduce an empty iterable?'
+        raise StopIteration(msg) from exc
+
+    for v in it:
+        acc = f(acc, v)
+
+    return acc
+
+
+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
+
+    .. 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: two parameter function, first parameter for accumulated value
+    :param initial: mandatory initial value to start fold
+    :return: the folded value
+
+    """
+    acc = initial
+    for v in iterable:
+        acc = f(acc, v)
+    return acc
+
+
+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()``
+
+    .. Warning::
+
+       This function never return if given an infinite iterable.
+
+    .. Warning::
+
+        This function returns a ``MayBe()`` when ``f`` raises any
+        exception what-so-ever. The exception is thrown away.
+
+    :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()
+
+    """
+    acc: L
+    it = iter(iterable)
+    if initial is NoValue():
+        try:
+            acc = cast(L, next(it))  # in this case L = D
+        except StopIteration:
+            return MayBe()
+    else:
+        acc = cast(L, initial)
+
+    for v in it:
+        try:
+            acc = f(acc, v)
+        except Exception:
+            return MayBe()
+
+    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[MayBe[D], Iterator[D]]:
+    """Short circuit version of a left reduce.
+
+    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: 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
+
+    """
+    it_start = drop_while(iterable, negate(start))
+    if not include_start:
+        try:
+            next(it_start)
+        except StopIteration:
+            pass
+    it_reduce, it_rest = take_while_split(it_start, negate(stop))
+    mb_reduced = maybe_fold_left(it_reduce, f)
+    if include_stop:
+        if mb_reduced:
+            try:
+                last = next(it_rest)
+                mb_reduced = MayBe(f(mb_reduced.get(), last))
+            except StopIteration:
+                pass
+        else:
+            try:
+                last = next(it_rest)
+                mb_reduced = MayBe(last)
+            except StopIteration:
+                pass
+
+    return (mb_reduced, it_rest)
+
+
+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[MayBe[D], Iterator[D]]:
+    """Short circuit version of a right reduce.
+
+    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: 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
+
+    """
+    it_start, it_rest = take_while_split(iterable, negate(start))
+    list1 = list(it_start)
+    if include_start:
+        try:
+            begin = next(it_rest)
+        except StopIteration:
+            pass
+        else:
+            list1.append(begin)
+
+    list1.reverse()
+    it_reduce, it_stop = take_while_split(list1, negate(stop))
+
+    mb_reduced = maybe_fold_left(it_reduce, swap(f))
+    if include_stop:
+        try:
+            end = next(it_stop)
+        except StopIteration:
+            pass
+        else:
+            if mb_reduced:
+                mb_reduced = MayBe(f(end, mb_reduced.get()))
+            else:
+                mb_reduced = MayBe(end)
+
+    return (mb_reduced, it_rest)

pythonic_fp/iterables/folding.pyi

@@ -0,0 +1,56 @@
+# Copyright 2023-2025 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Callable, Iterable, Iterator
+from typing import cast, Never
+from pythonic_fp.fptools.function import negate, swap
+from pythonic_fp.fptools.maybe import MayBe
+from pythonic_fp.sentinels.novalue import NoValue
+from .drop_take import drop_while, take_while_split
+
+__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 = 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 = NoValue()
+) -> MayBe[L] | Never: ...
+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[MayBe[D], Iterator[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[MayBe[D], Iterator[D]]: ...