Type redone

Author: sobolevn

CHANGELOG.md

@@ -9,6 +9,7 @@ We follow Semantic Versions since the `0.1.0` release.
 
 - Moves all types to `.pyi` files
 - Renames all classes according to new naming pattern
+- **HUGE** improvement of types
 
 
 ## Version 0.3.1

docs/index.rst

@@ -18,7 +18,7 @@ Contents
 
   pages/monad.rst
   pages/maybe.rst
-  pages/Result.rst
+  pages/result.rst
   pages/do-notation.rst
   pages/functions.rst
 

docs/pages/either.rst renamed to docs/pages/result.rst

@@ -1,8 +1,6 @@
 Result
 ======
 
-Also known as ``Result``.
-
 ``Result`` is obviously a result of some series of computations.
 It might succeed with some resulting value.
 Or it might return an error with some extra details.

returns/do_notation.pyi

@@ -1,14 +1,13 @@
 # -*- coding: utf-8 -*-
 
-from typing import Callable
+from typing import Callable, TypeVar
 
-from returns.primitives.types import MonadType
+from returns.primitives.monad import Monad
 
-# Typing decorators is not an easy task, see:
-# https://github.com/python/mypy/issues/3157
+_ReturnsMonad = TypeVar('_ReturnsMonad', bound=Callable[..., Monad])
 
 
 def do_notation(
-    function: Callable[..., MonadType],
-) -> Callable[..., MonadType]:
+    function: _ReturnsMonad,
+) -> _ReturnsMonad:
     ...

returns/functions.pyi

@@ -2,16 +2,20 @@
 
 from typing import Callable, TypeVar
 
-from returns.primitives.types import MonadType
+from returns.primitives.monad import Monad
 from returns.result import Result
 
+_MonadType = TypeVar('_MonadType', bound=Monad)
 _ReturnType = TypeVar('_ReturnType')
 
 
-def is_successful(monad: MonadType) -> bool:
+def is_successful(monad: _MonadType) -> bool:
     ...
 
 
+# Typing decorators is not an easy task, see:
+# https://github.com/python/mypy/issues/3157
+
 def safe(
     function: Callable[..., _ReturnType],
 ) -> Callable[..., Result[_ReturnType, Exception]]:

returns/maybe.py

@@ -1,17 +1,17 @@
 # -*- coding: utf-8 -*-
 
 from abc import ABCMeta
-from typing import Generic, TypeVar
+from typing import TypeVar
 
 from typing_extensions import Literal
 
 from returns.primitives.exceptions import UnwrapFailedError
-from returns.primitives.monad import Monad
+from returns.primitives.monad import GenericMonadOneSlot
 
 _ValueType = TypeVar('_ValueType')
 
 
-class Maybe(Generic[_ValueType], Monad[_ValueType], metaclass=ABCMeta):
+class Maybe(GenericMonadOneSlot[_ValueType], metaclass=ABCMeta):
     """
     Represents a result of a series of commutation that can return ``None``.
 

returns/maybe.pyi

@@ -5,14 +5,14 @@ from typing import Any, Callable, NoReturn, TypeVar, Union, overload
 
 from typing_extensions import Literal, final
 
-from returns.primitives.monad import Monad
+from returns.primitives.monad import GenericMonadOneSlot, Monad
 
-_MonadType = TypeVar('_MonadType', bound='Monad')
+_MonadType = TypeVar('_MonadType', bound=Monad)
 _ValueType = TypeVar('_ValueType')
 _NewValueType = TypeVar('_NewValueType')
 
 
-class Maybe(Monad[_ValueType], metaclass=ABCMeta):
+class Maybe(GenericMonadOneSlot[_ValueType], metaclass=ABCMeta):
     @overload
     @classmethod
     def new(cls, inner_value: Literal[None]) -> 'Nothing':  # type: ignore
@@ -26,19 +26,25 @@ class Maybe(Monad[_ValueType], metaclass=ABCMeta):
     def fmap(
         self,
         function: Callable[[_ValueType], _NewValueType],
-    ) -> _MonadType:
+    ) -> Union['Some[_NewValueType]', 'Maybe[_ValueType]']:
         ...
 
     def bind(
         self,
         function: Callable[[_ValueType], _MonadType],
-    ) -> _MonadType:
+    ) -> Union[_MonadType, 'Maybe[_ValueType]']:
         ...
 
-    def efmap(self, function) -> 'Some[_NewValueType]':
+    def efmap(
+        self,
+        function: Callable[[Literal[None]], '_NewValueType'],
+    ) -> Union['Some[_ValueType]', 'Some[_NewValueType]']:
         ...
 
-    def ebind(self, function) -> _MonadType:
+    def ebind(
+        self,
+        function: Callable[[Literal[None]], _MonadType],
+    ) -> Union[_MonadType, 'Maybe[_ValueType]']:
         ...
 
     def value_or(
@@ -61,10 +67,10 @@ class Nothing(Maybe[Any]):
     def __init__(self, inner_value: Literal[None] = ...) -> None:
         ...
 
-    def fmap(self, function) -> 'Nothing':  # type: ignore
+    def fmap(self, function) -> 'Nothing':
         ...
 
-    def bind(self, function) -> 'Nothing':  # type: ignore
+    def bind(self, function) -> 'Nothing':
         ...
 
     def efmap(
@@ -96,7 +102,7 @@ class Some(Maybe[_ValueType]):
     def __init__(self, inner_value: _ValueType) -> None:
         ...
 
-    def fmap(  # type: ignore
+    def fmap(
         self,
         function: Callable[[_ValueType], _NewValueType],
     ) -> 'Some[_NewValueType]':
@@ -108,10 +114,10 @@ class Some(Maybe[_ValueType]):
     ) -> _MonadType:
         ...
 
-    def efmap(self, function) -> 'Some[_ValueType]':  # type: ignore
+    def efmap(self, function) -> 'Some[_ValueType]':
         ...
 
-    def ebind(self, function) -> 'Some[_ValueType]':  # type: ignore
+    def ebind(self, function) -> 'Some[_ValueType]':
         ...
 
     def value_or(self, default_value: _NewValueType) -> _ValueType:

returns/primitives/exceptions.pyi

@@ -1,10 +1,14 @@
 # -*- coding: utf-8 -*-
 
-from returns.primitives.types import MonadType
+from typing import TypeVar
+
+from returns.primitives.monad import Monad
+
+_MonadType = TypeVar('_MonadType', bound=Monad)
 
 
 class UnwrapFailedError(Exception):
-    def __init__(self, monad: MonadType) -> None:
+    def __init__(self, monad: _MonadType) -> None:
         self.halted_monad = monad
 
 

returns/primitives/monad.py

@@ -6,9 +6,10 @@
 from returns.primitives.exceptions import ImmutableStateError
 
 _ValueType = TypeVar('_ValueType')
+_ErrorType = TypeVar('_ErrorType')
 
 
-class _BaseMonad(Generic[_ValueType], metaclass=ABCMeta):
+class _BaseMonad(object, metaclass=ABCMeta):
     """Utility class to provide all needed magic methods to the contest."""
 
     __slots__ = ('_inner_value',)
@@ -45,7 +46,7 @@ def __eq__(self, other):
         return self._inner_value == other._inner_value  # noqa: Z441
 
 
-class Monad(_BaseMonad[_ValueType]):
+class Monad(_BaseMonad, metaclass=ABCMeta):
     """
     Represents a "context" in which calculations can be executed.
 
@@ -131,3 +132,21 @@ def failure(self):  # pragma: no cover
         This method is the opposite of :meth:`~unwrap`.
         """
         raise NotImplementedError()
+
+
+class GenericMonadOneSlot(Generic[_ValueType], Monad):
+    """
+    Base class for monads with one typed slot.
+
+    Use this type for generic inheritance only.
+    Use :class:`~Monad` as a general type for polymorphism.
+    """
+
+
+class GenericMonadTwoSlots(Generic[_ValueType, _ErrorType], Monad):
+    """
+    Base class for monads with two typed slot.
+
+    Use this type for generic inheritance only.
+    Use :class:`~Monad` as a general type for polymorphism.
+    """

returns/primitives/monad.pyi

@@ -3,12 +3,11 @@
 from abc import ABCMeta, abstractmethod
 from typing import Any, Generic, NoReturn, TypeVar
 
-# These type variables are widely used in our source code.
 _ValueType = TypeVar('_ValueType')
-_NewValueType = TypeVar('_NewValueType')
+_ErrorType = TypeVar('_ErrorType')
 
 
-class _BaseMonad(Generic[_ValueType], metaclass=ABCMeta):
+class _BaseMonad(object, metaclass=ABCMeta):
     __slots__ = ('_inner_value',)
     _inner_value: Any
 
@@ -25,7 +24,7 @@ class _BaseMonad(Generic[_ValueType], metaclass=ABCMeta):
         ...
 
 
-class Monad(_BaseMonad[_ValueType]):
+class Monad(_BaseMonad, metaclass=ABCMeta):
     @abstractmethod
     def fmap(self, function):
         ...
@@ -47,9 +46,25 @@ class Monad(_BaseMonad[_ValueType]):
         ...
 
     @abstractmethod
-    def unwrap(self) -> _ValueType:
+    def unwrap(self):
         ...
 
     @abstractmethod
     def failure(self):
         ...
+
+
+class GenericMonadOneSlot(
+    Generic[_ValueType],
+    Monad,
+    metaclass=ABCMeta,
+):
+    ...
+
+
+class GenericMonadTwoSlots(
+    Generic[_ValueType, _ErrorType],
+    Monad,
+    metaclass=ABCMeta,
+):
+    ...