hkt for filter

Author: CucumisSativus

returns/interfaces/filterable.py

@@ -0,0 +1,41 @@
+from abc import abstractmethod
+from typing import Callable, Generic, TypeVar
+
+from returns.primitives.hkt import Kind1
+
+_InnerType = TypeVar('_InnerType')
+
+_FilterableType = TypeVar('_FilterableType', bound='Filterable')
+
+
+class Filterable(Generic[_InnerType]):
+    """
+    Represents container that can apply filter over inner value.
+
+    There are no aliases or ``FilterableN` for ``Filterable`` interface.
+    Because it always uses one type.
+
+    Not all types can be ``Filterable`` because we require
+    a possibility to access internal value and to model a case,
+    where the predicate is false
+
+    .. code:: python
+
+        >>> from returns.maybe import Nothing, Some
+        >>> from returns.pointfree import filter_
+
+        >>> def example(argument: int) -> bool:
+        ...     return argument % 2 == 0
+
+        >>> assert filter_(example)(Some(5)) == Nothing
+        >>> assert filter_(example)(Some(6)) == Some(6)
+        >>> assert filter_(example)(Nothing) == Nothing
+
+    """
+
+    @abstractmethod
+    def filter(
+        self: _FilterableType,
+        predicate: Callable[[_InnerType], bool],
+    ) -> Kind1[_FilterableType, _InnerType]:
+        """Applies 'predicate' to the result fo a previous computation."""

returns/maybe.py

@@ -141,23 +141,29 @@ def bind_optional(
 
         """
 
-    def filter(self,
-               function: Callable[[_ValueType], bool],
-               ) -> 'Maybe[_ValueType]':
+    def filter(
+        self,
+        function: Callable[[_ValueType], bool],
+    ) -> 'Maybe[_ValueType]':
         """
-        Apply a predicate over the value. If the predicate returns true it returns the original value wrapped with Some.
+        Apply a predicate over the value.
+
+        If the predicate returns true,
+        it returns the original value wrapped with Some.
         If the predicate returns false, Nothing is returned
 
         .. code:: python
 
-            >>> from returns.maybe import Maybe, Some, Nothing
+            >>> from returns.maybe import Some, Nothing
             >>> def predicate(value):
             ...     return value % 2 == 0
 
             >>> assert Some(5).filter(predicate) == Nothing
             >>> assert Some(6).filter(predicate) == Some(6)
             >>> assert Nothing.filter(predicate) == Nothing
+
         """
+
     def lash(
         self,
         function: Callable[[Any], Kind1['Maybe', _ValueType]],
@@ -356,7 +362,7 @@ def bind_optional(self, function):
         return self
 
     def filter(self, function):
-        """Does nothing for ``Nothing`` """
+        """Does nothing."""
         return self
 
     def lash(self, function):
@@ -436,10 +442,10 @@ def failure(self):
         raise UnwrapFailedError(self)
 
     def filter(self, function):
+        """Filters internal value."""
         if function(self._inner_value):
             return self
-        else:
-            return _Nothing()
+        return _Nothing()
 
 
 Maybe.success_type = Some
@@ -475,7 +481,9 @@ def maybe(
     Requires our :ref:`mypy plugin <mypy-plugins>`.
 
     """
+
     @wraps(function)
     def decorator(*args, **kwargs):
         return Maybe.from_optional(function(*args, **kwargs))
+
     return decorator

returns/pointfree/__init__.py

@@ -35,6 +35,7 @@
 from returns.pointfree.bind_result import bind_result as bind_result
 from returns.pointfree.compose_result import compose_result as compose_result
 from returns.pointfree.cond import cond as cond
+from returns.pointfree.filter import filter_ as filter_
 from returns.pointfree.lash import lash as lash
 from returns.pointfree.map import map_ as map_
 from returns.pointfree.modify_env import modify_env as modify_env

returns/pointfree/filter.py

@@ -0,0 +1,39 @@
+from typing import Callable, TypeVar
+
+from returns.interfaces.filterable import Filterable
+from returns.primitives.hkt import Kind1, Kinded, kinded
+
+_InnerType = TypeVar('_InnerType')
+_FilterableKind = TypeVar('_FilterableKind', bound=Filterable)
+
+
+def filter_(
+    predicate: Callable[[_InnerType], bool],
+) -> Kinded[Callable[
+    [Kind1[_FilterableKind, _InnerType]],
+    Kind1[_FilterableKind, _InnerType],
+]]:
+    """
+    Applies predicate over container.
+
+    This is how it should be used:
+
+    .. code:: python
+
+        >>> from returns.maybe import Some, Nothing
+
+        >>> def example(value):
+        ...     return value % 2 == 0
+
+        >>> assert filter_(example)(Some(5)) == Nothing
+        >>> assert filter_(example)(Some(6)) == Some(6)
+
+    """
+
+    @kinded
+    def factory(
+        container: Kind1[_FilterableKind, _InnerType],
+    ) -> Kind1[_FilterableKind, _InnerType]:
+        return container.filter(predicate)
+
+    return factory

tests/test_maybe/test_maybe_filter.py

@@ -1,10 +1,11 @@
-from returns.maybe import Maybe, Nothing, Some
+from returns.maybe import Nothing, Some
 
 
 def test_maybe_filter():
-    def predicate(value):
-        return value % 2 == 0
+    """Ensures that .filter works correctly."""
+    def factory(argument: int) -> bool:
+        return argument % 2 == 0
 
-    assert Some(5).filter(predicate) == Nothing
-    assert Some(6).filter(predicate) == Some(6)
-    assert Nothing.filter(predicate) == Nothing
+    assert Some(5).filter(factory) == Nothing
+    assert Some(6).filter(factory) == Some(6)
+    assert Nothing.filter(factory) == Nothing