Composes Result with IOResult

Author: sobolevn

README.md

@@ -340,22 +340,23 @@ Let's refactor it to make our
 
 ```python
 import requests
-from returns.io import IO, impure
-from returns.result import Result, safe
+from returns.io import IO, IOResult, impure_safe
+from returns.result import safe
 from returns.pipeline import pipe
 from returns.pointfree import bind
 
-def fetch_user_profile(user_id: int) -> Result['UserProfile', Exception]:
+def fetch_user_profile(user_id: int) -> IOResult['UserProfile', Exception]:
     """Fetches `UserProfile` TypedDict from foreign API."""
     return pipe(
         _make_request,
-        # after bind: def (Result) -> Result
-        # after IO.lift: def (IO[Result]) -> IO[Result]
-        IO.lift(bind(_parse_json)),
+        # before: def (Response) -> UserProfile
+        # after safe: def (Response) -> ResultE[UserProfile]
+        # after bind: def (ResultE[Response]) -> ResultE[UserProfile]
+        # after lift: def (IOResultE[Response]) -> IOResultE[UserProfile]
+        IOResult.lift_result(bind(_parse_json)),
     )(user_id)
 
-@impure
-@safe
+@impure_safe
 def _make_request(user_id: int) -> requests.Response:
     response = requests.get('/api/users/{0}'.format(user_id))
     response.raise_for_status()

returns/_generated/flatten.pyi

@@ -12,7 +12,6 @@ _ValueType = TypeVar('_ValueType')
 _ErrorType = TypeVar('_ErrorType')
 
 
-
 @overload
 def _flatten(container: IO[IO[_ValueType]]) -> IO[_ValueType]:
     ...

returns/_generated/pipeline.pyi

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from typing import Callable, Coroutine, Type, TypeVar, Union, overload
+from typing import Callable, Coroutine, Type, TypeVar, overload
 
 from typing_extensions import Protocol
 

returns/converters.py

@@ -1,12 +1,9 @@
 # -*- coding: utf-8 -*-
 
-from typing import TypeVar, overload
+from typing import TypeVar
 
 from returns._generated import fold
 from returns._generated.flatten import _flatten as flatten  # noqa: F401
-from returns.context import RequiresContext
-from returns.functions import identity
-from returns.io import IO
 from returns.maybe import Maybe
 from returns.result import Failure, Result, Success
 

returns/io.py

@@ -273,6 +273,36 @@ def bind(
             return function(self._inner_value.unwrap())
         return self  # type: ignore
 
+    def bind_result(
+        self,
+        function: Callable[
+            [_ValueType],
+            'Result[_NewValueType, _ErrorType]',
+        ],
+    ) -> 'IOResult[_NewValueType, _ErrorType]':
+        """
+        Composes successful container with a function that returns a container.
+
+        Similar to :meth:`~IOResult.bind`, but works with containers
+        that return :class:`returns.result.Result`
+        instead of :class:`~IOResult`.
+
+        .. code:: python
+
+          >>> from returns.io import IOResult, IOFailure, IOSuccess
+          >>> from returns.result import Result, Success
+
+          >>> def bindable(string: str) -> Result[str, str]:
+          ...      return Success(string + 'b')
+          ...
+          >>> assert IOSuccess('a').bind_result(bindable) == IOSuccess('ab')
+          >>> assert IOFailure('a').bind_result(bindable) == IOFailure('a')
+
+        """
+        if is_successful(self._inner_value):
+            return IOResult(function(self._inner_value.unwrap()))
+        return self  # type: ignore
+
     def fix(
         self,
         function: Callable[[_ErrorType], _NewValueType],
@@ -419,6 +449,21 @@ def lift(
         """
         return lambda container: container.map(function)
 
+    @classmethod
+    def lift_result(
+        cls,
+        function: Callable[[_ValueType], Result[_NewValueType, _ErrorType]],
+    ) -> Callable[
+        ['IOResult[_ValueType, _ErrorType]'],
+        'IOResult[_NewValueType, _ErrorType]',
+    ]:
+        """
+        Lifts function from ``Result`` to ``IOResult`` for better composition.
+
+        >>> assert False
+        """
+        ...
+
     @classmethod
     def from_typecast(
         cls, container: IO[Result[_ValueType, _ErrorType]],
@@ -469,7 +514,6 @@ def IOFailure(  # noqa: N802
     return IOResult(Failure(inner_value))
 
 
-
 # Aliases:
 
 #: A popular case for writing `Result` is using `Exception` as the last type.
@@ -495,7 +539,7 @@ def impure_safe(
     """Case for regular functions."""
 
 
-def impure_safe(function):
+def impure_safe(function):  # noqa: C901
     """
     Decorator to mark function that it returns :py:class:`IO` container.
 

returns/pipeline.py

@@ -3,13 +3,13 @@
 from typing import TYPE_CHECKING, Union
 
 from returns._generated.pipe import _pipe as pipe  # noqa: F401
-from returns._generated.pipeline import _pipeline as pipeline
+from returns._generated.pipeline import _pipeline as pipeline  # noqa: F401
 from returns.primitives.exceptions import UnwrapFailedError
 
 if TYPE_CHECKING:  # pragma: no cover
-    from returns.maybe import Maybe
-    from returns.result import Result
-    from returns.io import IOResult
+    from returns.maybe import Maybe  # noqa: WPS433
+    from returns.result import Result  # noqa: WPS433
+    from returns.io import IOResult  # noqa: WPS433
 
     # Logical aliases:
     _Unwrapable = Union[Result, Maybe, IOResult]

tests/test_converters/test_flatten.py

@@ -4,7 +4,7 @@
 
 from returns.context import Context
 from returns.converters import flatten
-from returns.io import IO, IOSuccess, IOFailure
+from returns.io import IO, IOFailure, IOSuccess
 from returns.maybe import Nothing, Some
 from returns.result import Failure, Success
 
@@ -21,7 +21,7 @@
 
     # Nope:
     (Failure(Failure('a')), Failure(Failure('a'))),
-    (IOFailure(IOFailure('a')), IOFailure(IOFailure('a')))
+    (IOFailure(IOFailure('a')), IOFailure(IOFailure('a'))),
 ])
 def test_flatten(container, merged):
     """Ensures that `join` is always returning the correct type."""