Refs #243

Author: sobolevn

docs/pages/context.rst

@@ -298,6 +298,8 @@ so you can work easily with it:
   allows to bind functions that return ``IOResult`` with just one call
 - :meth:`~RequiresContextIOResult.bind_context`
   allows to bind functions that return ``RequiresContext`` easily
+- :meth:`~RequiresContextIOResult.bind_context_result`
+  allows to bind functions that return ``RequiresContextResult`` easily
 - There are also several useful contructors from any possible type
 
 Use it when you work with impure context-related functions that might fail.

returns/context/requires_context_io_result.py

@@ -5,6 +5,7 @@
 from typing_extensions import final
 
 from returns.context.requires_context import RequiresContext
+from returns.context.requires_context_result import RequiresContextResult
 from returns.io import IO, IOFailure, IOResult, IOSuccess
 from returns.primitives.container import BaseContainer
 from returns.primitives.types import Immutable
@@ -273,6 +274,59 @@ def bind_context(
             ),
         )
 
+    def bind_context_result(
+        self,
+        function: Callable[
+            [_ValueType],
+            RequiresContextResult[_EnvType, _NewValueType, _ErrorType],
+        ],
+    ) -> 'RequiresContextIOResult[_EnvType, _NewValueType, _ErrorType]':
+        """
+        Binds ``RequiresContextResult`` returning function to the current one.
+
+        .. code:: python
+
+          >>> from returns.context import RequiresContextResult
+          >>> from returns.io import IOSuccess, IOFailure
+          >>> from returns.result import Success, Failure
+
+          >>> def function(arg: int) -> RequiresContextResult[str, int, int]:
+          ...     if arg > 0:
+          ...         return RequiresContextResult(
+          ...             lambda deps: Success(len(deps) + arg),
+          ...         )
+          ...     return RequiresContextResult(
+          ...         lambda deps: Failure(len(deps) + arg),
+          ...     )
+          ...
+          >>> assert function(2)('abc') == Success(5)
+          >>> assert function(-1)('abc') == Failure(2)
+
+          >>> assert RequiresContextIOResult.from_success(
+          ...    2,
+          ... ).bind_context_result(
+          ...     function,
+          ... )('abc') == IOSuccess(5)
+
+          >>> assert RequiresContextIOResult.from_success(
+          ...    -1,
+          ... ).bind_context_result(
+          ...     function,
+          ... )('abc') == IOFailure(2)
+
+          >>> assert RequiresContextIOResult.from_failure(
+          ...    2,
+          ... ).bind_context_result(
+          ...     function,
+          ... )('abc') == IOFailure(2)
+
+        """
+        return RequiresContextIOResult(
+            lambda deps: self(deps).bind_result(
+                lambda inner: function(inner)(deps),  # type: ignore
+            ),
+        )
+
     def bind_ioresult(
         self,
         function: Callable[[_ValueType], IOResult[_NewValueType, _ErrorType]],

tests/test_context/test_requires_context_io_result/test_context_io_result.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from returns.context import ContextIOResult, RequiresContextIOResult
+from returns.io import IOFailure, IOSuccess
+from returns.primitives.container import (
+    Altable,
+    Bindable,
+    Fixable,
+    Mappable,
+    Rescueable,
+    Unwrapable,
+)
+from returns.primitives.exceptions import ImmutableStateError
+from returns.result import Failure, Success
+
+
+@pytest.mark.parametrize('container', [
+    RequiresContextIOResult(lambda _: IOSuccess(1)),
+    RequiresContextIOResult(lambda _: IOFailure(1)),
+    RequiresContextIOResult.from_success(1),
+    RequiresContextIOResult.from_failure(1),
+    RequiresContextIOResult.from_result(Success(1)),
+    RequiresContextIOResult.from_result(Failure(1)),
+    RequiresContextIOResult.from_ioresult(IOSuccess(1)),
+    RequiresContextIOResult.from_ioresult(IOFailure(1)),
+    ContextIOResult.ask(),
+])
+@pytest.mark.parametrize('protocol', [
+    Bindable,
+    Mappable,
+    Rescueable,
+    Unwrapable,
+    Altable,
+    Fixable,
+])
+def test_protocols(container, protocol):
+    """Ensures that RequiresContext has all the right protocols."""
+    assert isinstance(container, protocol)
+
+
+def test_context_io_result_immutable():
+    """Ensures that helper is immutable."""
+    with pytest.raises(ImmutableStateError):
+        ContextIOResult().abc = 1
+
+
+def test_requires_context_result_immutable():
+    """Ensures that container is immutable."""
+    with pytest.raises(ImmutableStateError):
+        RequiresContextIOResult.from_success(1).abc = 1

tests/test_context/test_requires_context_io_result/test_requires_context_io_result_bind.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+
+from returns.context import RequiresContext
+from returns.context import RequiresContextIOResult as RCR  # noqa: N814
+from returns.context import RequiresContextResult
+from returns.io import IOFailure, IOResult, IOSuccess
+from returns.result import Failure, Result, Success
+
+
+def test_bind():
+    """Ensures that bind works."""
+    def factory(inner_value: int) -> RCR[int, float, str]:
+        if inner_value > 0:
+            return RCR(lambda deps: IOSuccess(inner_value / deps))
+        return RCR.from_failure(str(inner_value))
+
+    input_value = 5
+    bound: RCR[int, int, str] = RCR.from_success(input_value)
+    assert bound.bind(factory)(2) == factory(input_value)(2)
+    assert bound.bind(factory)(2) == IOSuccess(2.5)
+
+    assert RCR.from_success(0).bind(
+        factory,
+    )(2) == factory(0)(2) == IOFailure('0')
+
+
+def test_bind_regular_result():
+    """Ensures that regular ``Result`` can be bound."""
+    def factory(inner_value: int) -> Result[int, str]:
+        if inner_value > 0:
+            return Success(inner_value + 1)
+        return Failure('nope')
+
+    first: RCR[int, int, str] = RCR.from_success(1)
+    third: RCR[int, int, str] = RCR.from_failure('a')
+
+    assert first.bind_result(factory)(RCR.empty) == IOSuccess(2)
+    assert RCR.from_success(0).bind_result(
+        factory,
+    )(RCR.empty) == IOFailure('nope')
+    assert third.bind_result(factory)(RCR.empty) == IOFailure('a')
+
+
+def test_bind_io_result():
+    """Ensures that io ``Result`` can be bound."""
+    def factory(inner_value: int) -> IOResult[int, str]:
+        if inner_value > 0:
+            return IOSuccess(inner_value + 1)
+        return IOFailure('nope')
+
+    first: RCR[int, int, str] = RCR.from_success(1)
+    third: RCR[int, int, str] = RCR.from_failure('a')
+
+    assert first.bind_ioresult(factory)(RCR.empty) == IOSuccess(2)
+    assert RCR.from_success(0).bind_ioresult(
+        factory,
+    )(RCR.empty) == IOFailure('nope')
+    assert third.bind_ioresult(factory)(RCR.empty) == IOFailure('a')
+
+
+def test_bind_regular_context():
+    """Ensures that regular ``RequiresContext`` can be bound."""
+    def factory(inner_value: int) -> RequiresContext[int, float]:
+        return RequiresContext(lambda deps: inner_value / deps)
+
+    first: RCR[int, int, str] = RCR.from_success(1)
+    third: RCR[int, int, str] = RCR.from_failure('a')
+
+    assert first.bind_context(factory)(2) == IOSuccess(0.5)
+    assert RCR.from_success(2).bind_context(
+        factory,
+    )(1) == IOSuccess(2.0)
+    assert third.bind_context(factory)(1) == IOFailure('a')
+
+
+def test_bind_result_context():
+    """Ensures that ``RequiresContextResult`` can be bound."""
+    def factory(inner_value: int) -> RequiresContextResult[int, float, str]:
+        return RequiresContextResult(lambda deps: Success(inner_value / deps))
+
+    first: RCR[int, int, str] = RCR.from_success(1)
+    third: RCR[int, int, str] = RCR.from_failure('a')
+
+    assert first.bind_context_result(factory)(2) == IOSuccess(0.5)
+    assert RCR.from_success(2).bind_context_result(
+        factory,
+    )(1) == IOSuccess(2.0)
+    assert third.bind_context_result(factory)(1) == IOFailure('a')
+
+
+def test_rescue_success():
+    """Ensures that rescue works for Success container."""
+    def factory(inner_value) -> RCR[int, int, str]:
+        return RCR.from_success(inner_value * 2)
+
+    assert RCR.from_success(5).rescue(
+        factory,
+    )(0) == RCR.from_success(5)(0)
+    assert RCR.from_failure(5).rescue(
+        factory,
+    )(0) == RCR.from_success(10)(0)
+
+
+def test_rescue_failure():
+    """Ensures that rescue works for Failure container."""
+    def factory(inner_value) -> RCR[int, int, str]:
+        return RCR.from_failure(inner_value * 2)
+
+    assert RCR.from_success(5).rescue(
+        factory,
+    )(0) == RCR.from_success(5)(0)
+    assert RCR.from_failure(5).rescue(
+        factory,
+    )(0) == RCR.from_failure(10)(0)

tests/test_context/test_requires_context_io_result/test_requires_context_io_result_cast.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+from returns.context import RequiresContextIOResult, RequiresContextIOResultE
+
+
+def _function(arg: int) -> RequiresContextIOResultE[int, float]:
+    if arg == 0:
+        return RequiresContextIOResult.from_failure(
+            ZeroDivisionError('Divided by 0'),
+        )
+    return RequiresContextIOResult.from_success(10 / arg)
+
+
+def test_requires_context_io_resulte():
+    """Ensures that RequiresContextResultE correctly typecast."""
+    container: RequiresContextIOResult[int, float, Exception] = _function(1)
+    assert container(0) == RequiresContextIOResult.from_success(10.0)(0)

tests/test_context/test_requires_context_result/test_context_result.py

@@ -20,6 +20,8 @@
     RequiresContextResult(lambda _: Failure(1)),
     RequiresContextResult.from_success(1),
     RequiresContextResult.from_failure(1),
+    RequiresContextResult.from_result(Success(1)),
+    RequiresContextResult.from_result(Failure(1)),
     ContextResult.ask(),
 ])
 @pytest.mark.parametrize('protocol', [
@@ -36,6 +38,12 @@ def test_protocols(container, protocol):
 
 
 def test_context_result_immutable():
-    """Ensures that RequiresContext container supports ``.map()`` method."""
+    """Ensures that helper is immutable."""
     with pytest.raises(ImmutableStateError):
         ContextResult().abc = 1
+
+
+def test_requires_context_result_immutable():
+    """Ensures that container is immutable."""
+    with pytest.raises(ImmutableStateError):
+        RequiresContextResult.from_success(1).abc = 1

tests/test_context/test_requires_context_result/test_requires_context_result_bind.py

@@ -23,7 +23,7 @@ def factory(inner_value: int) -> RCR[int, float, str]:
 
 
 def test_bind_regular_result():
-    """Ensures that regular ``Result`` can be bound to ``IOResult``."""
+    """Ensures that regular ``Result`` can be bound."""
     def factory(inner_value: int) -> Result[int, str]:
         if inner_value > 0:
             return Success(inner_value + 1)
@@ -40,7 +40,7 @@ def factory(inner_value: int) -> Result[int, str]:
 
 
 def test_bind_regular_context():
-    """Ensures that regular ``Result`` can be bound to ``IOResult``."""
+    """Ensures that regular ``RequiresContext`` can be bound."""
     def factory(inner_value: int) -> RequiresContext[int, float]:
         return RequiresContext(lambda deps: inner_value / deps)