Broken: debuging mypy

Author: sobolevn

returns/io.py

@@ -4,31 +4,26 @@
 from functools import wraps
 from inspect import iscoroutinefunction
 from typing import (
-    Any,
     Callable,
-    Coroutine,
     ClassVar,
-    Type,
+    Coroutine,
     Generic,
     NoReturn,
+    Type,
     TypeVar,
     Union,
     overload,
 )
 
 from typing_extensions import final
 
-from returns.primitives.exceptions import UnwrapFailedError
 from returns._generated.squash import _squash as io_squash  # noqa: F401
-from returns.pipeline import is_successful
 from returns.primitives.container import BaseContainer
 from returns.result import Failure, Result, Success
 
 _ValueType = TypeVar('_ValueType', covariant=True)
 _NewValueType = TypeVar('_NewValueType')
 
-_T = TypeVar('_T', contravariant=True)
-
 # Result related:
 _ErrorType = TypeVar('_ErrorType', covariant=True)
 _NewErrorType = TypeVar('_NewErrorType')
@@ -575,11 +570,26 @@ def from_successful_io(
     def from_result(
         cls, container: Result[_NewValueType, _NewErrorType],
     ) -> 'IOResult[_NewValueType, _NewErrorType]':
-        """"""
+        """
+        Creates ``IOResult`` from ``Result`` value.
+
+        .. code:: python
+
+          >>> from returns.io import IOResult, IOSuccess, IOFailure
+          >>> from returns.result import Success, Failure
+
+          >>> assert IOResult.from_result(Success(1)) == IOSuccess(1)
+          >>> assert IOResult.from_result(Failure(2)) == IOFailure(2)
+
+        """
         if isinstance(container, container.success_type):
             return _IOSuccess(container)
         return _IOFailure(container)
 
+    def __str__(self) -> str:
+        """Custom ``str`` representation for better readability."""
+        return '<IOResult: {0}'.format(self._inner_value)
+
 
 @final
 class _IOFailure(IOResult):

returns/pipeline.py

@@ -1,18 +1,16 @@
 # -*- coding: utf-8 -*-
 
-from typing import TYPE_CHECKING, Union
+from typing import Union
 
 from returns._generated.pipe import _pipe as pipe  # noqa: F401
 from returns._generated.pipeline import _pipeline as pipeline  # noqa: F401
+from returns.io import IOResult
+from returns.maybe import Maybe
 from returns.primitives.exceptions import UnwrapFailedError
+from returns.result import Result
 
-if TYPE_CHECKING:  # pragma: no cover
-    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]
+# Logical aliases:
+_Unwrapable = Union[Result, Maybe, IOResult]
 
 
 def is_successful(container: '_Unwrapable') -> bool:

tests/test_io/test_ioresult_container/test_ioresult_bind.py

@@ -16,6 +16,7 @@ def factory(inner_value: int) -> IOResult[int, str]:
 
     assert bound.bind(factory) == factory(input_value)
     assert IOSuccess(input_value).bind(factory) == factory(input_value)
+    assert IOSuccess('a').bind(factory) == factory('a')
     assert str(bound.bind(factory)) == '<IOResult: <Success: 10>>'
 
     input_value = 0