Add mapi, append and delay for Seq and FrozenList (#18)

* Add mapi, append and delay for Seq and FrozenList

* Add test for seq delay

Author: dbrattli

.pre-commit-config.yaml

@@ -1,31 +1,30 @@
 exclude: "_version.py|versioneer.py"
 repos:
-- hooks:
-    - args:
-        - --remove-all-unused-imports
-        - --in-place
-      id: autoflake
-  repo: https://github.com/humitos/mirrors-autoflake
-  rev: v1.1
-- hooks:
-    - id: isort
-  repo: https://github.com/timothycrosley/isort
-  rev: 5.6.4
-- hooks:
-    - id: black
-  repo: https://github.com/psf/black
-  rev: 20.8b1
-- hooks:
-    - id: flake8
-  repo: https://gitlab.com/pycqa/flake8
-  rev: 3.8.4
-- hooks:
-  - id: pyright
-    name: pyright
-    entry: pyright
-    language: node
-    pass_filenames: false
-    types: [python]
-    additional_dependencies: ['[email protected]']
-  repo: local
-  
+  - hooks:
+      - args:
+          - --remove-all-unused-imports
+          - --in-place
+        id: autoflake
+    repo: https://github.com/humitos/mirrors-autoflake
+    rev: v1.1
+  - hooks:
+      - id: isort
+    repo: https://github.com/timothycrosley/isort
+    rev: 5.6.4
+  - hooks:
+      - id: black
+    repo: https://github.com/psf/black
+    rev: 20.8b1
+  - hooks:
+      - id: flake8
+    repo: https://gitlab.com/pycqa/flake8
+    rev: 3.8.4
+  - hooks:
+      - id: pyright
+        name: pyright
+        entry: pyright
+        language: node
+        pass_filenames: false
+        types: [python]
+        additional_dependencies: ["[email protected]"]
+    repo: local

expression/collections/frozenlist.py

@@ -21,6 +21,7 @@
 
 import builtins
 import functools
+import itertools
 from typing import (
     Any,
     Callable,
@@ -268,6 +269,23 @@ def map(self, mapping: Callable[[TSource], TResult]) -> FrozenList[TResult]:
         """
         return FrozenList((*builtins.map(mapping, self),))
 
+    def mapi(self, mapping: Callable[[int, TSource], TResult]) -> FrozenList[TResult]:
+        """Map list with index.
+
+        Builds a new collection whose elements are the results of
+        applying the given function to each of the elements of the
+        collection. The integer index passed to the function indicates
+        the index (from 0) of element being transformed.
+
+        Args:
+            mapping: The function to transform elements and their
+                indices.
+
+        Returns:
+            The list of transformed elements.
+        """
+        return FrozenList((*itertools.starmap(mapping, enumerate(self)),))
+
     @staticmethod
     def of(*args: TSource) -> FrozenList[TSource]:
         """Create list from a number of arguments."""
@@ -625,6 +643,28 @@ def _map(source: FrozenList[TSource]) -> FrozenList[TResult]:
     return _map
 
 
+def mapi(mapper: Callable[[int, TSource], TResult]) -> Projection[TSource, TResult]:
+    """Map list with index.
+
+    Builds a new collection whose elements are the results of
+    applying the given function to each of the elements of the
+    collection. The integer index passed to the function indicates
+    the index (from 0) of element being transformed.
+
+    Args:
+        mapping: The function to transform elements and their
+            indices.
+
+    Returns:
+        The list of transformed elements.
+    """
+
+    def _mapi(source: FrozenList[TSource]) -> FrozenList[TResult]:
+        return source.mapi(mapper)
+
+    return _mapi
+
+
 def of(*args: TSource) -> FrozenList[TSource]:
     """Create list from a number of arguments."""
     return FrozenList((*args,))
@@ -812,6 +852,7 @@ def _zip(source: FrozenList[TSource]) -> FrozenList[Tuple[TSource, TResult]]:
     "item",
     "is_empty",
     "map",
+    "mapi",
     "of_seq",
     "of_option",
     "singleton",

expression/collections/seq.py

@@ -56,6 +56,11 @@ def of(cls, *args: TSource) -> Seq[TSource]:
     def of_iterable(cls, source: Iterable[TSource]) -> Seq[TSource]:
         return cls(source)
 
+    def append(self, *others: Iterable[TSource]) -> Seq[TSource]:
+        """Wraps the two given enumerations as a single concatenated
+        enumeration."""
+        return Seq(concat(self, *others))
+
     def filter(self, predicate: Callable[[TSource], bool]) -> Seq[TSource]:
         return Seq(filter(predicate)(self))
 
@@ -81,6 +86,20 @@ def collect(self, mapping: Callable[[TSource], "Seq[TResult]"]) -> Seq[TResult]:
         xs = pipe(self, collect(mapping))
         return Seq(xs)
 
+    @staticmethod
+    def delay(generator: Callable[[], Iterable[TSource]]) -> Iterable[TSource]:
+        """Returns a sequence that is built from the given delayed specification of a
+        sequence.
+
+        The input function is evaluated each time an IEnumerator for the sequence
+        is requested.
+
+        Args:
+            generator: The generating function for the sequence.
+        """
+
+        return delay(generator)
+
     @staticmethod
     def empty() -> Seq[TSource]:
         """Returns empty sequence."""
@@ -123,6 +142,23 @@ def map(self, mapper: Callable[[TSource], TResult]) -> Seq[TResult]:
 
         return Seq(map(mapper)(self))
 
+    def mapi(self, mapping: Callable[[int, TSource], TResult]) -> Seq[TResult]:
+        """Map list with index.
+
+        Builds a new collection whose elements are the results of
+        applying the given function to each of the elements of the
+        collection. The integer index passed to the function indicates
+        the index (from 0) of element being transformed.
+
+        Args:
+            mapping: The function to transform elements and their
+                indices.
+
+        Returns:
+            The list of transformed elements.
+        """
+        return Seq(mapi(mapping)(self))
+
     @overload
     def match(self) -> Case[Iterable[TSource]]:
         ...
@@ -242,6 +278,16 @@ def __call__(self, __source: Iterable[TSource]) -> Iterable[TResult]:
         raise NotImplementedError
 
 
+def append(*others: Iterable[TSource]) -> Projection[TSource, TSource]:
+    """Wraps the given enumerations as a single concatenated
+    enumeration."""
+
+    def _(source: Iterable[TSource]) -> Iterable[TSource]:
+        return concat(source, *others)
+
+    return _
+
+
 def choose(chooser: Callable[[TSource], Option[TResult]]) -> Projection[TSource, TResult]:
     """Choose items from the sequence.
 
@@ -290,6 +336,31 @@ def concat(*iterables: Iterable[TSource]) -> Iterable[TSource]:
             yield element
 
 
+def delay(generator: Callable[[], Iterable[TSource]]) -> Iterable[TSource]:
+    """Returns a sequence that is built from the given delayed
+    specification of a sequence.
+
+    The input function is evaluated each time an Iterator for the
+    sequence is requested.
+
+    Args:
+        generator: The generating function for the sequence.
+    """
+
+    class Delayed(Iterable[TResult]):
+        """An infinite iterable where each iterator starts counting at
+        0."""
+
+        def __init__(self, gen: Callable[[], Iterable[TResult]]) -> None:
+            self.gen = gen
+
+        def __iter__(self) -> Iterator[TResult]:
+            xs = self.gen()
+            return builtins.iter(xs)
+
+    return Delayed(generator)
+
+
 empty: Seq[Any] = Seq()
 """The empty sequence."""
 
@@ -481,6 +552,28 @@ def _map(source: Iterable[TSource]) -> Iterable[TResult]:
     return _map
 
 
+def mapi(mapping: Callable[[int, TSource], TResult]) -> Projection[TSource, TResult]:
+    """Map list with index.
+
+    Builds a new collection whose elements are the results of
+    applying the given function to each of the elements of the
+    collection. The integer index passed to the function indicates
+    the index (from 0) of element being transformed.
+
+    Args:
+        mapping: The function to transform elements and their
+            indices.
+
+    Returns:
+        The list of transformed elements.
+    """
+
+    def _mapi(source: Iterable[TSource]) -> Iterable[TResult]:
+        return (*itertools.starmap(mapping, builtins.enumerate(source)),)
+
+    return _mapi
+
+
 def max(source: Iterable[TSupportsLessThan]) -> TSupportsLessThan:
     """Returns the greatest of all elements of the sequence,
     compared via `max()`."""
@@ -680,16 +773,19 @@ def _zip(source2: Iterable[TResult]) -> Iterable[Tuple[TSource, TResult]]:
 
 __all__ = [
     "Seq",
+    "append",
     "choose",
     "concat",
     "collect",
+    "delay",
     "empty",
     "filter",
     "fold",
     "fold_back",
     "head",
     "iter",
     "map",
+    "mapi",
     "max",
     "min",
     "min_by",

expression/core/aiotools.py

@@ -68,15 +68,15 @@ def cb():
 def start_immediate(computation: Awaitable[Any], token: Optional[CancellationToken] = None) -> None:
     task = asyncio.create_task(computation)
 
-    def cb():
+    def cb() -> None:
         task.cancel()
 
     if token:
         token.register(cb)
     return None
 
 
-def run_synchronous(computation: Awaitable[TSource]) -> TSource:
+def run_synchronously(computation: Awaitable[TSource]) -> TSource:
     """Runs the asynchronous computation and await its result."""
     return asyncio.run(computation)
 
@@ -114,4 +114,5 @@ async def from_result(result: TSource) -> TSource:
     "sleep",
     "start",
     "start_immediate",
+    "run_synchronously",
 ]

expression/core/misc.py

@@ -20,7 +20,7 @@ def starid(*value: Any) -> Tuple[Any, ...]:
     return value
 
 
-def flip(fn: Callable[[A, B], Any]) -> Callable[[B, A], Any]:
+def flip(fn: Callable[[A, B], TResult]) -> Callable[[B, A], TResult]:
     """Flips the arguments for a function taking two arguments.
 
     Example:
@@ -33,14 +33,14 @@ def _flip(b: B, a: A) -> Any:
     return _flip
 
 
-def snd(value: Tuple[Any, B]) -> B:
+def snd(value: Tuple[Any, TSource]) -> TSource:
     """Return second argument of the tuple."""
 
     _, b = value
     return b
 
 
-def fst(value: Tuple[A, Any]) -> A:
+def fst(value: Tuple[TSource, Any]) -> TSource:
     """Return first argument of the tuple."""
 
     a, _ = value

tests/test_frozenlist.py

@@ -100,6 +100,18 @@ def mapper(x: int):
     assert [y for y in zs] == [mapper(x) for x in xs]
 
 
+@given(st.lists(st.integers()))
+def test_list_pipe_mapi(xs: List[int]):
+    def mapper(i: int, x: int):
+        return x + i
+
+    ys = frozenlist.of_seq(xs)
+    zs = ys.pipe(frozenlist.mapi(mapper))
+
+    assert isinstance(zs, FrozenList)
+    assert [z for z in zs] == [x + i for i, x in enumerate(xs)]
+
+
 @given(st.lists(st.integers()))
 def test_list_len(xs: List[int]):
     ys = frozenlist.of_seq(xs)