Either now has two types

Author: sobolevn

dry_monads/do_notation.py

@@ -22,3 +22,19 @@ def decorator(*args, **kwargs) -> _MonadType:
         except UnwrapFailedError as exc:
             return exc.halted_monad
     return decorator
+
+# from dry_monads.either import Success, Failure, Either
+
+# @do_notation
+# def test() -> Success[int]:
+#     def example(incoming: int) -> Either[int, int]:
+#         return Failure("abc")
+
+#     first = example(1).unwrap()
+#     second = example(2).unwrap()
+#     reveal_type(first)  # dry_monads/do.py:35: error: Revealed type is 'builtins.int*'
+#     reveal_type(second)  # dry_monads/do.py:36: error: Revealed type is 'builtins.int*'
+#     return Success(first + second)
+
+# reveal_type(test())  # dry_monads/do.py:39: error: Revealed type is 'dry_monads.either.Right*[builtins.int]'
+# print(test())

dry_monads/either.py

@@ -1,35 +1,59 @@
 # -*- coding: utf-8 -*-
 
-from typing import Callable, NoReturn
+from abc import ABCMeta, abstractmethod
+from typing import Callable, NoReturn, Generic, TypeVar, Any, Union, NewType
+from typing_extensions import Protocol
 
 from dry_monads.primitives.exceptions import UnwrapFailedError
-from dry_monads.primitives.monad import Monad, NewValueType, ValueType
+from dry_monads.primitives.monad import NewValueType, ValueType, Monad
 
+ErrorType = TypeVar('ErrorType')
 
-class Either(Monad[ValueType]):
+
+class Either(Generic[ValueType, ErrorType]):
     """
     Represents a calculation that may either fail or succeed.
 
     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')
+    and 'Left' (or its alias 'Failure').
     """
 
+    _inner_value: Union[ValueType, ErrorType]
+
+    @abstractmethod
+    def unwrap(self) -> ValueType:
+        """
+        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 Left(Either[ValueType]):
+class Left(Either[Any, ErrorType], Monad[ErrorType]):
     """
     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 fmap(self, function) -> 'Left[ValueType]':
+    def __init__(self, inner_value: ErrorType) -> None:
+        """
+        Wraps the given value in the Container.
+
+        'value' is any arbitrary value of any type including functions.
+        """
+        self._inner_value = inner_value
+
+    def fmap(self, function) -> 'Left[ErrorType]':
         """Returns the 'Left' instance that was used to call the method."""
         return Left(self._inner_value)
 
-    def bind(self, function) -> 'Left[ValueType]':
+    def bind(self, function) -> 'Left[ErrorType]':
         """Returns the 'Left' instance that was used to call the method."""
         return Left(self._inner_value)
 
@@ -42,13 +66,21 @@ def unwrap(self) -> NoReturn:
         raise UnwrapFailedError(self)
 
 
-class Right(Either[ValueType]):
+class Right(Either[ValueType, Any], Monad[ValueType]):
     """
     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.
+        """
+        self._inner_value = inner_value
+
     def fmap(
         self,
         function: Callable[[ValueType], NewValueType],
@@ -65,8 +97,8 @@ def fmap(
 
     def bind(
         self,
-        function: Callable[[ValueType], Either[NewValueType]],
-    ) -> Either[NewValueType]:
+        function: Callable[[ValueType], Either[NewValueType, ErrorType]],
+    ) -> Either[NewValueType, ErrorType]:
         """
         Applies 'function' to the result of a previous calculation.
 
@@ -89,3 +121,11 @@ def unwrap(self) -> ValueType:
 Result = Either
 Success = Right
 Failure = Left
+
+# def function(trigger: int) -> Either[int, bool]:
+#     if trigger > 1:
+#         reveal_type(Success(''))
+#         return Success('')
+#     else:
+#         reveal_type(Failure(''))
+#         return Failure('-')

dry_monads/primitives/monad.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 from abc import ABCMeta, abstractmethod
-from typing import Generic, TypeVar
+from typing import Any, TypeVar, Generic
 
 ValueType = TypeVar('ValueType')
 NewValueType = TypeVar('NewValueType')
@@ -19,15 +19,7 @@ class Monad(Generic[ValueType], metaclass=ABCMeta):
 
     """
 
-    _inner_value: ValueType
-
-    def __init__(self, inner_value: ValueType) -> None:
-        """
-        Wraps the given value in the Container.
-
-        'value' is any arbitrary value of any type including functions.
-        """
-        self._inner_value = inner_value
+    _inner_value: Any
 
     @abstractmethod
     def fmap(self, function):  # pragma: no cover