Update type hints to pyright 1.1.96 (#13)

* Update type hints to pyright 1.1.96

* Rename TransformFn protocol to Projection

Author: dbrattli

.pre-commit-config.yaml

@@ -26,6 +26,6 @@ repos:
     language: node
     pass_filenames: false
     types: [python]
-    additional_dependencies: ['[email protected].95']
+    additional_dependencies: ['[email protected].96']
   repo: local
 

expression/collections/frozenlist.py

@@ -432,21 +432,14 @@ def __repr__(self) -> str:
         return str(self)
 
 
-class ExitFn(Protocol):
+class Cata(Protocol[TSource, TResult]):
     """A partially applied exit function."""
 
-    def __call__(self, source: FrozenList[TSource]) -> TSource:
+    def __call__(self, source: FrozenList[TSource]) -> TResult:
         ...
 
 
-class FilterFn(Protocol):
-    """A partially applied filter function."""
-
-    def __call__(self, __source: FrozenList[TSource]) -> FrozenList[TSource]:
-        ...
-
-
-class TransformFn(Protocol[TResult]):
+class Projection(Protocol[TSource, TResult]):
     """A partially applied filter function."""
 
     def __call__(self, __source: FrozenList[TSource]) -> FrozenList[TResult]:
@@ -592,7 +585,7 @@ def indexed(source: FrozenList[TSource]) -> FrozenList[Tuple[int, TSource]]:
     return source.indexed()
 
 
-def item(index: int) -> ExitFn:
+def item(index: int) -> Cata[TSource, TSource]:
     """Indexes into the list. The first element has index 0.
 
     Args:
@@ -608,12 +601,12 @@ def _item(source: FrozenList[TSource]) -> TSource:
     return _item
 
 
-def is_empty(source: FrozenList[TSource]) -> bool:
+def is_empty(source: FrozenList[Any]) -> bool:
     """Returns `True` if the list is empty, `False` otherwise."""
     return source.is_empty()
 
 
-def map(mapper: Callable[[TSource], TResult]) -> TransformFn[TResult]:
+def map(mapper: Callable[[TSource], TResult]) -> Projection[TSource, TResult]:
     """Map list.
 
     Builds a new collection whose elements are the results of applying
@@ -671,7 +664,7 @@ def singleton(value: TSource) -> FrozenList[TSource]:
     return FrozenList((value,))
 
 
-def skip(count: int) -> FilterFn:
+def skip(count: int) -> Projection[TSource, TSource]:
     """Returns the list after removing the first N elements.
 
     Args:
@@ -687,7 +680,7 @@ def _skip(source: FrozenList[TSource]) -> FrozenList[TSource]:
     return _skip
 
 
-def skip_last(count: int) -> FilterFn:
+def skip_last(count: int) -> Projection[TSource, TSource]:
     """Returns the list after removing the last N elements.
 
     Args:
@@ -707,7 +700,7 @@ def tail(source: FrozenList[TSource]) -> FrozenList[TSource]:
     return source.tail()
 
 
-def take(count: int) -> FilterFn:
+def take(count: int) -> Projection[TSource, TSource]:
     """Returns the first N elements of the list.
 
     Args:
@@ -723,7 +716,7 @@ def _take(source: FrozenList[TSource]) -> FrozenList[TSource]:
     return _take
 
 
-def take_last(count: int) -> FilterFn:
+def take_last(count: int) -> Projection[TSource, TSource]:
     """Returns a specified number of contiguous elements from the end of
     the list.
 

expression/collections/map.py

@@ -351,14 +351,14 @@ def _change(table: Map[Key, Value]) -> Map[Key, Value]:
     return _change
 
 
-def contains_key(key: Key) -> Callable[[Map[Key, Value]], bool]:
-    def _contains_key(table: Map[Key, Value]) -> bool:
+def contains_key(key: Key) -> Callable[[Map[Key, Any]], bool]:
+    def _contains_key(table: Map[Key, Any]) -> bool:
         return table.contains_key(key)
 
     return _contains_key
 
 
-def count(table: Map[Key, Value]) -> int:
+def count(table: Map[Any, Any]) -> int:
     """Return the number of bindings in the map."""
     return len(table)
 
@@ -383,7 +383,7 @@ def _find(table: Map[Key, Value]) -> Value:
     return _find
 
 
-def is_empty(table: Map[Key, Value]) -> bool:
+def is_empty(table: Map[Any, Any]) -> bool:
     """Is the map empty?
 
     Args:
@@ -558,7 +558,7 @@ def try_find(key: Key) -> Callable[[Map[Key, Value]], Option[Value]]:
         instance and returns the result.
     """
 
-    def _try_find(table: Map[Key, Value]):
+    def _try_find(table: Map[Key, Value]) -> Option[Value]:
         """Lookup an element in the map, returning a `Some` value if the
         element is in the domain of the map and `Nothing` if not.
 

expression/collections/maptree.py

@@ -56,11 +56,11 @@ class MapTreeNode(MapTreeLeaf[Key, Value]):
 empty: MapTree[Any, Any] = Nothing
 
 
-def is_empty(m: MapTree[Key, Value]):
+def is_empty(m: MapTree[Any, Any]):
     return m.is_none()
 
 
-def size_aux(acc: int, m: MapTree[Key, Value]) -> int:
+def size_aux(acc: int, m: MapTree[Any, Any]) -> int:
     for m2 in m.to_list():
         if isinstance(m2, MapTreeNode):
             mn = cast(MapTreeNode[Key, Value], m2)
@@ -71,11 +71,11 @@ def size_aux(acc: int, m: MapTree[Key, Value]) -> int:
         return acc
 
 
-def size(x: MapTree[Key, Value]):
+def size(x: MapTree[Any, Any]):
     return size_aux(0, x)
 
 
-def height(m: MapTree[Key, Value]) -> int:
+def height(m: MapTree[Any, Any]) -> int:
     for m2 in m.to_list():
         if isinstance(m2, MapTreeNode):
             mn = cast(MapTreeNode[Key, Value], m2)
@@ -324,7 +324,7 @@ def change(k: Key, u: Callable[[Option[Value]], Option[Value]], m: MapTree[Key,
             return m
 
 
-def mem(k: Key, m: MapTree[Key, Value]) -> bool:
+def mem(k: Key, m: MapTree[Key, Any]) -> bool:
     for m2 in m.to_list():
         if isinstance(m2, MapTreeNode):
             mn = cast(MapTreeNode[Key, Value], m2)

expression/collections/seq.py

@@ -231,27 +231,18 @@ def __iter__(self) -> Iterator[TSource]:
         return builtins.iter(self._value)
 
 
-class FilterFn(Protocol):
-    """Sequence filtering protocol function.
+class Projection(Protocol[TSource, TResult]):
+    """Sequence transformation protocol.
 
-    `Iterable[TSource]) -> Iterable[TSource]`
-    """
-
-    def __call__(self, __source: Iterable[TSource]) -> Iterable[TSource]:
-        raise NotImplementedError
-
-
-class TransformFn(Protocol[TResult]):
-    """Sequence transforming protocol function.
-
-    `Iterable[TSource]) -> Iterable[TResult]`
+    A sequence transformation protocol that encapsulates a function of
+    type `Iterable[TSource]) -> Iterable[TResult]`
     """
 
     def __call__(self, __source: Iterable[TSource]) -> Iterable[TResult]:
         raise NotImplementedError
 
 
-def choose(chooser: Callable[[TSource], Option[TResult]]) -> TransformFn[TResult]:
+def choose(chooser: Callable[[TSource], Option[TResult]]) -> Projection[TSource, TResult]:
     """Choose items from the sequence.
 
     Applies the given function to each element of the list. Returns
@@ -275,7 +266,7 @@ def mapper(x: TSource) -> Iterable[TResult]:
     return _choose
 
 
-def collect(mapping: Callable[[TSource], Iterable[TResult]]) -> TransformFn[TResult]:
+def collect(mapping: Callable[[TSource], Iterable[TResult]]) -> Projection[TSource, TResult]:
     def _collect(source: Iterable[TSource]) -> Iterable[TResult]:
         return (x for xs in source for x in mapping(xs))
 
@@ -303,7 +294,7 @@ def concat(*iterables: Iterable[TSource]) -> Iterable[TSource]:
 """The empty sequence."""
 
 
-def filter(predicate: Callable[[TSource], bool]) -> FilterFn:
+def filter(predicate: Callable[[TSource], bool]) -> Projection[TSource, TSource]:
     """Filter sequence.
 
     Filters the sequence to a new sequence containing only the
@@ -463,7 +454,7 @@ def _iter(source: Iterable[TSource]) -> None:
     return _iter
 
 
-def map(mapper: Callable[[TSource], TResult]) -> TransformFn[TResult]:
+def map(mapper: Callable[[TSource], TResult]) -> Projection[TSource, TResult]:
     """Map source sequence.
 
     Builds a new collection whose elements are the results of
@@ -593,7 +584,7 @@ def singleton(item: TSource) -> Seq[TSource]:
     return Seq([item])
 
 
-def take(count: int) -> FilterFn:
+def take(count: int) -> Projection[Any, Any]:
     """Returns the first N elements of the sequence.
 
     Args:
@@ -709,6 +700,7 @@ def _zip(source2: Iterable[TResult]) -> Iterable[Tuple[TSource, TResult]]:
     "scan",
     "singleton",
     "take",
+    "Projection",
     "unfold",
     "zip",
 ]

expression/core/choice.py

@@ -50,13 +50,13 @@ def __init__(self, value: A) -> None:
 
     @overload
     @classmethod
-    def match(cls, case: Case[Choice2[A_, B_]]) -> Iterable[A_]:
+    def match(cls, case: Case[Choice2[A_, Any]]) -> Iterable[A_]:
         """Helper to cast the match result to correct type."""
         ...
 
     @overload
     @classmethod
-    def match(cls, case: "Case[Choice1of2[A_, B_]]") -> Iterable[A_]:
+    def match(cls, case: "Case[Choice1of2[A_, Any]]") -> Iterable[A_]:
         """Helper to cast the match result to correct type."""
         ...
 
@@ -84,13 +84,13 @@ def __init__(self, value: B) -> None:
 
     @overload
     @classmethod
-    def match(cls, case: Case[Choice2[A_, B_]]) -> Iterable[B_]:
+    def match(cls, case: Case[Choice2[Any, B_]]) -> Iterable[B_]:
         """Helper to cast the match result to correct type."""
         ...
 
     @overload
     @classmethod
-    def match(cls, case: "Case[Choice1of2[A_, B_]]") -> Iterable[B_]:
+    def match(cls, case: "Case[Choice1of2[Any, B_]]") -> Iterable[B_]:
         """Helper to cast the match result to correct type."""
         ...
 

expression/core/misc.py

@@ -33,14 +33,14 @@ def _flip(b: B, a: A) -> Any:
     return _flip
 
 
-def snd(value: Tuple[A, B]) -> B:
+def snd(value: Tuple[Any, B]) -> B:
     """Return second argument of the tuple."""
 
     _, b = value
     return b
 
 
-def fst(value: Tuple[A, B]) -> A:
+def fst(value: Tuple[A, Any]) -> A:
     """Return first argument of the tuple."""
 
     a, _ = value

expression/core/option.py

@@ -174,7 +174,7 @@ def is_none(self) -> bool:
         """Returns `False`."""
         return False
 
-    def map(self, mapper: Callable[[TSource], TResult]):
+    def map(self, mapper: Callable[[TSource], TResult]) -> Option[TResult]:
         return Some(mapper(self._value))
 
     def map2(self, mapper: Callable[[TSource, T2], TResult], other: Option[T2]) -> Option[TResult]:
@@ -343,7 +343,7 @@ def __str__(self):
         return "Nothing"
 
 
-class TransformFn(Protocol[TResult]):
+class Projection(Protocol[TSource, TResult]):
     """Option transforming protocol function.
 
     `Option[TSource]) -> Option[TResult]`
@@ -365,7 +365,7 @@ def __call__(self, __source: Option[TSource]) -> Option[TResult]:
 """
 
 
-def bind(mapper: Callable[[TSource], Option[TResult]]) -> TransformFn[TResult]:
+def bind(mapper: Callable[[TSource], Option[TResult]]) -> Projection[TSource, TResult]:
     """Bind option.
 
     Applies and returns the result of the mapper if the value is
@@ -398,15 +398,15 @@ def _default_value(option: Option[TSource]) -> TSource:
     return _default_value
 
 
-def is_none(option: Option[TSource]) -> bool:
+def is_none(option: Option[Any]) -> bool:
     return option.is_none()
 
 
-def is_some(option: Option[TSource]) -> bool:
+def is_some(option: Option[Any]) -> bool:
     return option.is_some()
 
 
-def map(mapper: Callable[[TSource], TResult]) -> TransformFn[TResult]:
+def map(mapper: Callable[[TSource], TResult]) -> Projection[TSource, TResult]:
     def _map(option: Option[TSource]) -> Option[TResult]:
         return option.map(mapper)
 
@@ -485,4 +485,5 @@ def of_obj(value: Any) -> Option[Any]:
     "to_seq",
     "of_optional",
     "of_obj",
+    "Projection",
 ]

expression/core/pipe.py

@@ -96,7 +96,7 @@ def pipe(
     __fn6: Callable[[F], G],
     __fn7: Callable[[G], H],
     __fn8: Callable[[H], T],
-) -> H:
+) -> T:
     ...
 
 
@@ -146,7 +146,7 @@ def pipe2(values: Tuple[A, B], __fn1: Callable[[A, B], C], __fn2: Callable[[C],
 
 
 @overload
-def pipe2(values: Tuple[A, B], __fn1: Callable[[A, B], C], __fn2: Callable[[C], D], __fn3: Callable[[D], E]) -> D:
+def pipe2(values: Tuple[A, B], __fn1: Callable[[A, B], C], __fn2: Callable[[C], D], __fn3: Callable[[D], E]) -> E:
     ...