Fixes CI

Author: sobolevn

README.md

@@ -60,10 +60,13 @@ Make sure you know how to get started, [check out our docs](https://returns.read
 `None` is called the [worst mistake in the history of Computer Science](https://www.infoq.com/presentations/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare/).
 
 So, what can we do to check for `None` in our programs?
-You can use `Optional` and write a lot of `if some is not None:` conditions.
+You can use builtin [Optional](https://mypy.readthedocs.io/en/stable/kinds_of_types.html#optional-types-and-the-none-type) type
+and write a lot of `if some is not None:` conditions.
 But, having them here and there makes your code unreadable.
 
 ```python
+user: Optional[User]
+
 if user is not None:
      balance = user.get_balance()
      if balance is not None:
@@ -100,7 +103,9 @@ Forget about `None`-related errors forever!
 And that's how your initial refactored code will look like:
 
 ```python
-can_buy_stuff = Maybe.new(user).map(  # will have type: Maybe[bool]
+user: Optional[User]
+
+can_buy_stuff: Maybe[bool] = Maybe.new(user).map(  # type hint is not required
     lambda real_user: real_user.get_balance(),
 ).map(
     lambda balance: balance.credit_amount(),

poetry.lock

@@ -214,6 +214,31 @@ class IOResult(BaseContainer, Generic[_ValueType, _ErrorType]):
     Note, that even methods like :meth:`~IOResult.unwrap``
     and :meth:`~IOResult.value_or` return values wrapped in ``IO``.
 
+    ``IOResult`` is a complex compound value that consists of:
+
+    - raw value
+    - ``Result``
+    - ``IO``
+
+    This is why it has so many helper and factory methods:
+
+    - You can construct ``IOResult`` from raw value
+      with :func:`~IOSuccess` and :func:`~IOFailure` public type constructors
+    - You can construct ``IOResult`` from ``IO`` values
+      with :meth:`~IOResult.from_failed_io`
+      and :meth:`IOResult.from_successful_io`
+    - You can construct ``IOResult`` from ``Result`` values
+      with :meth:`~IOResult.__init__`
+
+    We also have a lot of utility methods for better function composition like:
+
+    - :meth:`~IOResult.bind_result` to work
+      with functions which return ``Result``
+    - :meth:`~IOResult.from_typecast` to work with ``IO[Result[...]]`` values
+    - :meth:`~IOResult.lift` and `~IOResult.lift_result` to allow
+      indirect function composition
+      with regular and ``Result`` based functions.
+
     See also:
         https://github.com/gcanti/fp-ts/blob/master/docs/modules/IOEither.ts.md
 
@@ -289,7 +314,7 @@ def bind_result(
 
         .. code:: python
 
-          >>> from returns.io import IOResult, IOFailure, IOSuccess
+          >>> from returns.io import IOFailure, IOSuccess
           >>> from returns.result import Result, Success
 
           >>> def bindable(string: str) -> Result[str, str]:
@@ -460,9 +485,21 @@ def lift_result(
         """
         Lifts function from ``Result`` to ``IOResult`` for better composition.
 
-        >>> assert False
+        Similar to :meth:`~IOResult.lift`, but works with other types.
+
+        .. code:: python
+
+          >>> from returns.io import IOResult, IOSuccess
+          >>> from returns.result import Result, Success
+
+          >>> def returns_result(arg: int) -> Result[int, str]:
+          ...     return Success(arg + 1)
+          ...
+          >>> returns_ioresult = IOResult.lift_result(returns_result)
+          >>> assert returns_ioresult(IOSuccess(1)) == IOSuccess(2)
+
         """
-        ...
+        return lambda container: container.bind_result(function)
 
     @classmethod
     def from_typecast(
@@ -481,6 +518,38 @@ def from_typecast(
         """
         return cls(container._inner_value)  # noqa: WPS437
 
+    @classmethod
+    def from_failed_io(
+        cls, container: IO[_ErrorType],
+    ) -> 'IOResult[NoReturn, _ErrorType]':
+        """
+        Creates new ``IOResult`` from "failed" ``IO`` container.
+
+        .. code:: python
+
+          >>> from returns.io import IO, IOResult, IOFailure
+          >>> container = IO(1)
+          >>> assert IOResult.from_failed_io(container) == IOFailure(1)
+
+        """
+        return IOFailure(container._inner_value)  # noqa: WPS437
+
+    @classmethod
+    def from_successful_io(
+        cls, container: IO[_ValueType],
+    ) -> 'IOResult[_ValueType, NoReturn]':
+        """
+        Creates new ``IOResult`` from "successful" ``IO`` container.
+
+        .. code:: python
+
+          >>> from returns.io import IO, IOResult, IOSuccess
+          >>> container = IO(1)
+          >>> assert IOResult.from_successful_io(container) == IOSuccess(1)
+
+        """
+        return IOSuccess(container._inner_value)  # noqa: WPS437
+
 
 def IOSuccess(  # noqa: N802
     inner_value: _NewValueType,

returns/io.py

@@ -45,6 +45,7 @@ class Result(
 
     See also:
         https://bit.ly/361qQhi
+        https://hackernoon.com/the-throw-keyword-was-a-mistake-l9e532di
 
     """
 

returns/result.py

@@ -39,8 +39,8 @@ exclude =
 ignore = D100, D104, D401, W504, X100, WPS202, WPS214, WPS320, WPS436, WPS440, TAE002, RST303, RST304, DAR103, DAR203
 
 per-file-ignores =
-  # Disable some pydocstyle checks for package:
-  returns/*.py: D104
+  # Disable some quality checks for the most heavy parts:
+  returns/io.py: WPS402
   # Disable imports in `__init__.py`:
   returns/__init__.py: F401, WPS412
   # There are multiple assert's in tests:

setup.cfg

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 from returns.io import IOFailure, IOResult, IOSuccess
+from returns.result import Failure, Result, Success
 
 
 def test_bind():
@@ -45,6 +46,18 @@ def factory(inner_value: int) -> IOResult[int, int]:
     assert bound.bind(factory) == IOFailure(input_value)
 
 
+def test_bind_regular_result():
+    """Ensures that regular ``Result`` can be bound to ``IOResult``."""
+    def factory(inner_value: int) -> Result[int, str]:
+        if inner_value > 0:
+            return Success(inner_value + 1)
+        return Failure('nope')
+
+    assert IOSuccess(1).bind_result(factory) == IOSuccess(2)
+    assert IOSuccess(0).bind_result(factory) == IOFailure('nope')
+    assert IOFailure('a').bind_result(factory) == IOFailure('a')
+
+
 def test_rescue_success():
     """Ensures that rescue works for IOSuccess container."""
     def factory(inner_value) -> IOResult[int, str]:

tests/test_io/test_ioresult_container/test_ioresult_bind.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+from returns.io import IOFailure, IOSuccess
+
+
+def test_map_iosuccess():
+    """Ensures that IOSuccess is mappable."""
+    assert IOSuccess(5).map(str) == IOSuccess('5')
+
+
+def test_alt_iofailure():
+    """Ensures that IOFailure is mappable."""
+    assert IOFailure(5).map(str) == IOFailure(5)
+    assert IOFailure(5).alt(str) == IOFailure('5')
+
+
+def test_fix_iosuccess():
+    """Ensures that IOSuccess.fix is NoOp."""
+    assert IOSuccess(5).fix(str) == IOSuccess(5)
+    assert IOSuccess(5).alt(str) == IOSuccess(5)
+
+
+def test_fix_iofailure():
+    """Ensures that IOFailure.fix produces the IOSuccess."""
+    assert IOFailure(5).fix(str) == IOSuccess('5')

tests/test_io/test_ioresult_container/test_ioresult_map.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from returns.io import IO, IOFailure, IOSuccess
+from returns.primitives.exceptions import UnwrapFailedError
+
+
+def test_ioresult_value_or():
+    """Ensures that ``value_or`` works correctly."""
+    assert IOSuccess(1).value_or(0) == IO(1)
+    assert IOFailure(1).value_or(0) == IO(0)
+
+
+def test_unwrap_iosuccess():
+    """Ensures that unwrap works for IOSuccess container."""
+    assert IOSuccess(5).unwrap() == IO(5)
+
+
+def test_unwrap_iofailure():
+    """Ensures that unwrap works for IOFailure container."""
+    with pytest.raises(UnwrapFailedError):
+        assert IOFailure(5).unwrap()
+
+
+def test_unwrap_iofailure_with_exception():
+    """Ensures that unwrap raises from the original exception."""
+    expected_exception = ValueError('error')
+    with pytest.raises(UnwrapFailedError) as excinfo:
+        IOFailure(expected_exception).unwrap()
+
+    assert 'ValueError: error' in str(  # type: ignore
+        excinfo.getrepr(),  # noqa: WPS441
+    )
+
+
+def test_failure_iosuccess():
+    """Ensures that failure works for IOSuccess container."""
+    with pytest.raises(UnwrapFailedError):
+        IOSuccess(5).failure()
+
+
+def test_failure_iofailure():
+    """Ensures that failure works for IOFailure container."""
+    assert IOFailure(5).failure() == IO(5)

tests/test_io/test_ioresult_container/test_ioresult_values.py

@@ -8,7 +8,7 @@ def test_map_success():
     assert Success(5).map(str) == Success('5')
 
 
-def test_alt():
+def test_alt_failure():
     """Ensures that Failure is mappable."""
     assert Failure(5).map(str) == Failure(5)
     assert Failure(5).alt(str) == Failure('5')

tests/test_result/test_result_map.py

@@ -45,7 +45,7 @@
     container: IOResult[int, str]
     fold_ioresult(first, second)(container)
   out: |
-    main:11: error: Argument 1 has incompatible type "Callable[[int], float]"; expected "Callable[[int], IO[<nothing>]]" (diff)
+    main:11: error: Argument 1 has incompatible type "Callable[[int], float]"; expected "Callable[[int], IO[<nothing>]]"
     main:11: error: Argument 2 has incompatible type "Callable[[str], float]"; expected "Callable[[str], IO[<nothing>]]"