Bind filter to maybe n

Author: CucumisSativus

returns/interfaces/filterable.py

@@ -1,14 +1,17 @@
 from abc import abstractmethod
-from typing import Callable, Generic, TypeVar
+from typing import Callable, NoReturn, TypeVar
 
+from returns.interfaces.specific.maybe import MaybeLikeN
 from returns.primitives.hkt import Kind1
 
-_InnerType = TypeVar('_InnerType')
+_FirstType = TypeVar('_FirstType')
+_SecondType = TypeVar('_SecondType')
+_ThirdType = TypeVar('_ThirdType')
 
-_FilterableType = TypeVar('_FilterableType', bound='Filterable')
+_FilterableType = TypeVar('_FilterableType', bound='FilterableN')
 
 
-class Filterable(Generic[_InnerType]):
+class FilterableN(MaybeLikeN[_FirstType, _SecondType, _ThirdType]):
     """
     Represents container that can apply filter over inner value.
 
@@ -36,6 +39,16 @@ class Filterable(Generic[_InnerType]):
     @abstractmethod
     def filter(
         self: _FilterableType,
-        predicate: Callable[[_InnerType], bool],
-    ) -> Kind1[_FilterableType, _InnerType]:
+        predicate: Callable[[_FirstType], bool],
+    ) -> Kind1[_FilterableType, _FirstType]:
         """Applies 'predicate' to the result fo a previous computation."""
+
+
+#: Type alias for kinds with one type argument.
+Filterable1 = FilterableN[_FirstType, NoReturn, NoReturn]
+
+#: Type alias for kinds with two type arguments.
+Filterable2 = FilterableN[_FirstType, _SecondType, NoReturn]
+
+#: Type alias for kinds with three type arguments.
+Filterable3 = FilterableN[_FirstType, _SecondType, _ThirdType]

returns/pointfree/filter.py

@@ -1,17 +1,19 @@
 from typing import Callable, TypeVar
 
-from returns.interfaces.filterable import Filterable
-from returns.primitives.hkt import Kind1, Kinded, kinded
+from returns.interfaces.filterable import FilterableN
+from returns.primitives.hkt import Kinded, KindN, kinded
 
-_InnerType = TypeVar('_InnerType')
-_FilterableKind = TypeVar('_FilterableKind', bound=Filterable)
+_FirstType = TypeVar('_FirstType')
+_SecondType = TypeVar('_SecondType')
+_ThirdType = TypeVar('_ThirdType')
+_FilterableKind = TypeVar('_FilterableKind', bound=FilterableN)
 
 
 def filter_(
-    predicate: Callable[[_InnerType], bool],
+    predicate: Callable[[_FirstType], bool],
 ) -> Kinded[Callable[
-    [Kind1[_FilterableKind, _InnerType]],
-    Kind1[_FilterableKind, _InnerType],
+    [KindN[_FilterableKind, _FirstType, _SecondType, _ThirdType]],
+    KindN[_FilterableKind, _FirstType, _SecondType, _ThirdType],
 ]]:
     """
     Applies predicate over container.
@@ -32,8 +34,8 @@ def filter_(
 
     @kinded
     def factory(
-        container: Kind1[_FilterableKind, _InnerType],
-    ) -> Kind1[_FilterableKind, _InnerType]:
+        container: KindN[_FilterableKind, _FirstType, _SecondType, _ThirdType],
+    ) -> KindN[_FilterableKind, _FirstType, _SecondType, _ThirdType]:
         return container.filter(predicate)
 
     return factory