Add seq choose and tests

Author: dbrattli

expression/collections/seq.py

@@ -50,6 +50,23 @@ def __init__(self, iterable: Iterable[TSource] = []) -> None:
     def filter(self, predicate: Callable[[TSource], bool]) -> "Seq[TSource]":
         return Seq(filter(predicate)(self))
 
+    def choose(self, chooser: Callable[[TSource], Option[TResult]]) -> "Seq[TResult]":
+        """Choose items from the sequence.
+
+        Applies the given function to each element of the list. Returns
+        the list comprised of the results x for each element where the
+        function returns `Some(x)`.
+
+        Args:
+            chooser: The function to generate options from the elements.
+
+        Returns:
+            The list comprising the values selected from the chooser
+            function.
+        """
+
+        return Seq(pipe(self, choose(chooser)))
+
     def collect(self, mapping: Callable[[TSource], "Seq[TResult]"]) -> "Seq[TResult]":
         return Seq(collect(mapping)(self))
 
@@ -91,16 +108,16 @@ def map(self, mapper: Callable[[TSource], TResult]) -> "Seq[TResult]":
         return Seq(map(mapper)(self))
 
     @overload
-    def match(self) -> "Case":
+    def match(self) -> "Case[Iterable[TSource]]":
         ...
 
     @overload
     def match(self, pattern: Any) -> Iterable[Iterable[TSource]]:
         ...
 
     def match(self, pattern: Any) -> Any:
-        m = Case(self)
-        return m.case(pattern) if pattern else m
+        case: Case[Iterable[TSource]] = Case(self)
+        return case(pattern) if pattern else case
 
     @overload
     def pipe(self, __fn1: Callable[["Seq[TSource]"], TResult]) -> TResult:
@@ -193,6 +210,30 @@ def __iter__(self) -> Iterator[TSource]:
         return builtins.iter(self._value)
 
 
+def choose(chooser: Callable[[TSource], Option[TResult]]) -> Callable[[Iterable[TSource]], Iterable[TResult]]:
+    """Choose items from the sequence.
+
+    Applies the given function to each element of the list. Returns
+    the list comprised of the results x for each element where the
+    function returns `Some(x)`.
+
+    Args:
+        chooser: The function to generate options from the elements.
+
+    Returns:
+        The list comprising the values selected from the chooser
+        function.
+    """
+
+    def _choose(source: Iterable[TSource]) -> Iterable[TResult]:
+        def mapper(x: TSource) -> Iterable[TResult]:
+            return chooser(x).to_seq()
+
+        return pipe(source, collect(mapper))
+
+    return _choose
+
+
 def collect(mapping: Callable[[TSource], Iterable[TResult]]) -> Callable[[Iterable[TSource]], Iterable[TResult]]:
     def _collect(source: Iterable[TSource]) -> Iterable[TResult]:
         return (x for xs in source for x in mapping(xs))
@@ -437,19 +478,21 @@ def _min_by(source: Iterable[TSource]) -> TSupportsLessThan:
     return _min_by
 
 
-def of(value: Iterable[TSource]) -> Seq[TSource]:
+def of(*args: TSource) -> Seq[TSource]:
     """Create sequence from iterable.
 
     Enables fluent dot chaining on the created sequence object.
     """
-    return Seq(value)
+    return Seq(args)
+
 
+def of_iterable(source: Iterable[TSource]) -> Seq[TSource]:
+    """Alias to `Seq.of`."""
+    return Seq(source)
 
-of_list = of
-"""Alias to `Seq.of`."""
 
-of_iterable = of
-"""Alias to `Seq.of`."""
+of_list = of_iterable
+"""Alias to `seq.of_iterable`."""
 
 
 @overload
@@ -570,6 +613,7 @@ def _zip(source2: Iterable[TResult]) -> Iterable[Tuple[TSource, TResult]]:
 
 __all__ = [
     "Seq",
+    "choose",
     "concat",
     "collect",
     "empty",

tests/test_asyncseq.py

@@ -1,9 +1,5 @@
-import asyncio
-from typing import Callable, Generator, Iterable, List
-
 import pytest
 from expression.collections.asyncseq import AsyncSeq
-from expression.core import pipe
 from hypothesis import given
 from hypothesis import strategies as st
 

tests/test_result.py

@@ -2,8 +2,7 @@
 
 import pytest
 from expression import effect
-from expression.core import Error, Ok, Result, Try, match, result
-from expression.core.result_try import Failure, Success
+from expression.core import Error, Failure, Ok, Result, Success, Try, match, result
 from expression.extra.result import pipeline, sequence
 from hypothesis import given
 from hypothesis import strategies as st

tests/test_seq.py

@@ -1,11 +1,11 @@
 import functools
 from itertools import accumulate
-from typing import Callable, Generator, Iterable, List, Tuple
+from typing import Callable, Generator, Iterable, List, Optional, Tuple
 
 import pytest
 from expression import effect
 from expression.collections import Seq, seq
-from expression.core import Nothing, Option, Some, pipe
+from expression.core import Nothing, Option, Some, option, pipe
 from hypothesis import given
 from hypothesis import strategies as st
 
@@ -80,22 +80,22 @@ def test_seq_head_empty_source():
 
 @given(st.lists(st.integers(), min_size=1))
 def test_seq_head_fluent(xs: List[int]):
-    value = seq.of(xs).head()
+    value = seq.of_iterable(xs).head()
 
     assert value == xs[0]
 
 
 @given(st.lists(st.integers(), min_size=1), st.integers())
 def test_seq_fold_pipe(xs: List[int], s: int):
     folder: Callable[[int, int], int] = lambda s, v: s + v
-    value = pipe(seq.of(xs), seq.fold(folder, s))
+    value = pipe(seq.of_iterable(xs), seq.fold(folder, s))
 
     assert value == sum(xs) + s
 
 
 @given(st.lists(st.integers(), min_size=1), st.integers())
 def test_seq_fold_fluent(xs: List[int], s: int):
-    value = seq.of(xs).fold(lambda s, v: s + v, s)
+    value = seq.of_iterable(xs).fold(lambda s, v: s + v, s)
 
     assert value == sum(xs) + s
 
@@ -115,15 +115,15 @@ def unfolder(state: int) -> Option[Tuple[int, int]]:
 @given(st.lists(st.integers(), min_size=1), st.integers())
 def test_seq_scan_pipe(xs: List[int], s: int):
     func: Callable[[int, int], int] = lambda s, v: s + v
-    value = pipe(seq.of(xs), seq.scan(func, s))
+    value = pipe(seq.of_iterable(xs), seq.scan(func, s))
 
     assert list(value) == list(accumulate(xs, func, initial=s))
 
 
 @given(st.lists(st.integers(), min_size=1), st.integers())
 def test_seq_scan_fluent(xs: List[int], s: int):
     func: Callable[[int, int], int] = lambda s, v: s + v
-    value = seq.of(xs).scan(func, s)
+    value = seq.of_iterable(xs).scan(func, s)
 
     assert list(value) == list(accumulate(xs, func, initial=s))
 
@@ -158,14 +158,31 @@ def test_seq_collect(xs: List[int]):
 
 @given(st.lists(st.integers()))
 def test_seq_pipeline(xs: List[int]):
-    ys = seq.of(xs).pipe(
+    ys = seq.of_iterable(xs).pipe(
         seq.map(lambda x: x * 10),
         seq.filter(lambda x: x > 100),
         seq.fold(lambda s, x: s + x, 0),
     )
     assert ys == functools.reduce(lambda s, x: s + x, filter(lambda x: x > 100, map(lambda x: x * 10, xs)), 0)
 
 
+def test_seq_choose_option():
+    xs = seq.of(None, 42)
+
+    chooser = seq.choose(option.of_optional)
+    ys = pipe(xs, chooser)
+
+    assert list(ys) == [42]
+
+
+def test_seq_choose_option_fluent():
+    xs = seq.of(None, 42)
+
+    ys = xs.choose(option.of_optional)
+
+    assert list(ys) == [42]
+
+
 @given(st.lists(st.integers()))
 def test_seq_infinite(xs: List[int]):
     ys = pipe(xs, seq.zip(seq.infinite))