Moves all types to .pyi files

Author: sobolevn

returns/do_notation.py

@@ -1,25 +1,18 @@
 # -*- coding: utf-8 -*-
 
 from functools import wraps
-from typing import Callable
 
 from returns.primitives.exceptions import UnwrapFailedError
-from returns.primitives.types import MonadType
 
-# Typing decorators is not an easy task, see:
-# https://github.com/python/mypy/issues/3157
 
-
-def do_notation(
-    function: Callable[..., MonadType],
-) -> Callable[..., MonadType]:
+def do_notation(function):
     """
     Decorator to enable 'do-notation' context.
 
     Should be used for series of computations that rely on ``.unwrap`` method.
     """
     @wraps(function)
-    def decorator(*args, **kwargs) -> MonadType:
+    def decorator(*args, **kwargs):
         try:
             return function(*args, **kwargs)
         except UnwrapFailedError as exc:

returns/do_notation.pyi

@@ -5,6 +5,9 @@ from typing import Callable
 from returns.primitives.types import MonadType
 
 
+# Typing decorators is not an easy task, see:
+# https://github.com/python/mypy/issues/3157
+
 def do_notation(
     function: Callable[..., MonadType],
 ) -> Callable[..., MonadType]:

returns/either.py

@@ -1,73 +1,32 @@
 # -*- coding: utf-8 -*-
 
-from abc import ABCMeta, abstractmethod
-from typing import Any, Callable, Generic, NoReturn, TypeVar, Union
-
-from typing_extensions import final
+from abc import ABCMeta
 
 from returns.primitives.exceptions import UnwrapFailedError
-from returns.primitives.monad import Monad, NewValueType, ValueType
-from returns.primitives.types import MonadType
-
-_ErrorType = TypeVar('_ErrorType')
-
-
-# That's the most ugly part.
-# We need to express `Either` with two type parameters and
-# Left and Right with just one parameter.
-# And that's how we do it. Any other and more cleaner ways are appreciated.
-class Either(Generic[ValueType, _ErrorType], metaclass=ABCMeta):
-    """
-    Represents a calculation that may either fail or succeed.
+from returns.primitives.monad import Monad
 
-    An alternative to using exceptions.
-    'Either' (or its alias 'Result') is an abstract type and should not
-    be instantiated directly. Instead use 'Right' (or its alias 'Success')
-    and 'Left' (or its alias 'Failure').
-    """
-
-    _inner_value: Union[ValueType, _ErrorType]
-
-    @abstractmethod
-    def unwrap(self) -> ValueType:  # pragma: no cover
-        """
-        Custom magic method to unwrap inner value from monad.
 
-        Should be redefined for ones that actually have values.
-        And for ones that raise an exception for no values.
-        """
-        raise NotImplementedError()
+class Either(Monad, metaclass=ABCMeta):
+    """Base class for Left and Right."""
 
 
-@final
-class Left(Either[Any, _ErrorType], Monad[_ErrorType]):
+class Left(Either):
     """
     Represents a calculation which has failed.
 
     It should contain an error code or message.
     To help with readability you may alternatively use the alias 'Failure'.
     """
 
-    def __init__(self, inner_value: _ErrorType) -> None:
-        """
-        Wraps the given value in the Container.
-
-        'value' is any arbitrary value of any type including functions.
-        """
-        object.__setattr__(self, '_inner_value', inner_value)
-
-    def fmap(self, function) -> 'Left[_ErrorType]':
+    def fmap(self, function):
         """Returns the 'Left' instance that was used to call the method."""
         return self
 
-    def bind(self, function) -> 'Left[_ErrorType]':
+    def bind(self, function):
         """Returns the 'Left' instance that was used to call the method."""
         return self
 
-    def efmap(
-        self,
-        function: Callable[[_ErrorType], NewValueType],
-    ) -> 'Right[NewValueType]':
+    def efmap(self, function):
         """
         Applies function to the inner value.
 
@@ -78,7 +37,7 @@ def efmap(
         """
         return Right(function(self._inner_value))
 
-    def ebind(self, function: Callable[[_ErrorType], MonadType]) -> MonadType:
+    def ebind(self, function):
         """
         Applies 'function' to the result of a previous calculation.
 
@@ -87,39 +46,27 @@ def ebind(self, function: Callable[[_ErrorType], MonadType]) -> MonadType:
         """
         return function(self._inner_value)
 
-    def value_or(self, default_value: NewValueType) -> NewValueType:
+    def value_or(self, default_value):
         """Returns the value if we deal with 'Right' or default if 'Left'."""
         return default_value
 
-    def unwrap(self) -> NoReturn:
+    def unwrap(self):
         """Raises an exception, since it does not have a value inside."""
         raise UnwrapFailedError(self)
 
-    def failure(self) -> _ErrorType:
+    def failure(self):
         """Unwraps inner error value from failed monad."""
         return self._inner_value
 
 
-@final
-class Right(Either[ValueType, Any], Monad[ValueType]):
+class Right(Either):
     """
     Represents a calculation which has succeeded and contains the result.
 
     To help with readability you may alternatively use the alias 'Success'.
     """
 
-    def __init__(self, inner_value: ValueType) -> None:
-        """
-        Wraps the given value in the Container.
-
-        'value' is any arbitrary value of any type including functions.
-        """
-        object.__setattr__(self, '_inner_value', inner_value)
-
-    def fmap(
-        self,
-        function: Callable[[ValueType], NewValueType],
-    ) -> 'Right[NewValueType]':
+    def fmap(self, function):
         """
         Applies function to the inner value.
 
@@ -130,10 +77,7 @@ def fmap(
         """
         return Right(function(self._inner_value))
 
-    def bind(
-        self,
-        function: Callable[[ValueType], MonadType],
-    ) -> MonadType:
+    def bind(self, function):
         """
         Applies 'function' to the result of a previous calculation.
 
@@ -142,23 +86,23 @@ def bind(
         """
         return function(self._inner_value)
 
-    def efmap(self, function) -> 'Right[ValueType]':
+    def efmap(self, function):
         """Returns the 'Right' instance that was used to call the method."""
         return self
 
-    def ebind(self, function) -> 'Right[ValueType]':
+    def ebind(self, function):
         """Returns the 'Right' instance that was used to call the method."""
         return self
 
-    def value_or(self, default_value: NewValueType) -> ValueType:
+    def value_or(self, default_value):
         """Returns the value if we deal with 'Right' or default if 'Left'."""
         return self._inner_value
 
-    def unwrap(self) -> ValueType:
+    def unwrap(self):
         """Returns the unwrapped value from the inside of this monad."""
         return self._inner_value
 
-    def failure(self) -> NoReturn:
+    def failure(self):
         """Raises an exception, since it does not have an error inside."""
         raise UnwrapFailedError(self)
 

returns/either.pyi

@@ -14,6 +14,10 @@ _MonadType = TypeVar('_MonadType', bound=Union['Monad', 'Either'])
 _ErrorType = TypeVar('_ErrorType')
 
 
+# That's the ugliest part.
+# We need to express `Either` with two type parameters and
+# Left and Right with just one parameter.
+# And that's how we do it. Any other and more cleaner ways are appreciated.
 class Either(Generic[ValueType, _ErrorType], metaclass=ABCMeta):
     _inner_value: Union[ValueType, _ErrorType]
 

returns/functions.py

@@ -1,16 +1,13 @@
 # -*- coding: utf-8 -*-
 
 from functools import wraps
-from typing import Callable, TypeVar
 
 from returns.either import Either, Failure, Success
 from returns.primitives.exceptions import UnwrapFailedError
 from returns.primitives.types import MonadType
 
-_ReturnType = TypeVar('_ReturnType')
 
-
-def is_successful(monad: MonadType) -> bool:
+def is_successful(monad):
     """Determins if a monad was a success or not."""
     try:
         monad.unwrap()
@@ -20,17 +17,15 @@ def is_successful(monad: MonadType) -> bool:
         return True
 
 
-def safe(
-    function: Callable[..., _ReturnType],
-) -> Callable[..., Either[_ReturnType, Exception]]:
+def safe(function):
     """
     Decorator to covert exception throwing function to 'Either' monad.
 
     Show be used with care, since it only catches 'Exception' subclasses.
     It does not catch 'BaseException' subclasses.
     """
     @wraps(function)
-    def decorator(*args, **kwargs) -> Either[_ReturnType, Exception]:
+    def decorator(*args, **kwargs):
         try:
             return Success(function(*args, **kwargs))
         except Exception as exc: