Seems like ready

Author: sobolevn

dry_monads/do_notation.py

@@ -1,14 +1,16 @@
 # -*- coding: utf-8 -*-
 
 from functools import wraps
-from typing import TYPE_CHECKING, Callable, TypeVar
+from typing import TYPE_CHECKING, Callable, TypeVar, Union
 
+from dry_monads.either import Either
 from dry_monads.primitives.exceptions import UnwrapFailedError
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from dry_monads.primitives.monad import Monad  # noqa: Z435, F401
 
-_MonadType = TypeVar('_MonadType', bound='Monad')
+# We need to have this ugly type because there is no other way around it:
+_MonadType = TypeVar('_MonadType', bound=Union['Monad', Either])
 
 
 def do_notation(
@@ -22,19 +24,3 @@ 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,16 +1,21 @@
 # -*- coding: utf-8 -*-
 
 from abc import ABCMeta, abstractmethod
-from typing import Callable, NoReturn, Generic, TypeVar, Any, Union, NewType
-from typing_extensions import Protocol
+from typing import Any, Callable, Generic, NoReturn, TypeVar, Union
+
+from typing_extensions import final
 
 from dry_monads.primitives.exceptions import UnwrapFailedError
-from dry_monads.primitives.monad import NewValueType, ValueType, Monad
+from dry_monads.primitives.monad import Monad, NewValueType, ValueType
 
 ErrorType = TypeVar('ErrorType')
 
 
-class Either(Generic[ValueType, 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.
 
@@ -23,7 +28,7 @@ class Either(Generic[ValueType, ErrorType]):
     _inner_value: Union[ValueType, ErrorType]
 
     @abstractmethod
-    def unwrap(self) -> ValueType:
+    def unwrap(self) -> ValueType:  # pragma: no cover
         """
         Custom magic method to unwrap inner value from monad.
 
@@ -33,6 +38,7 @@ def unwrap(self) -> ValueType:
         raise NotImplementedError()
 
 
+@final
 class Left(Either[Any, ErrorType], Monad[ErrorType]):
     """
     Represents a calculation which has failed.
@@ -66,6 +72,7 @@ def unwrap(self) -> NoReturn:
         raise UnwrapFailedError(self)
 
 
+@final
 class Right(Either[ValueType, Any], Monad[ValueType]):
     """
     Represents a calculation which has succeeded and contains the result.
@@ -121,11 +128,3 @@ 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 Any, TypeVar, Generic
+from typing import Any, Generic, TypeVar
 
 ValueType = TypeVar('ValueType')
 NewValueType = TypeVar('NewValueType')
@@ -40,12 +40,12 @@ def bind(self, function):  # pragma: no cover
         raise NotImplementedError()
 
     @abstractmethod
-    def value_or(self, default_value):
+    def value_or(self, default_value):  # pragma: no cover
         """Forces to unwrap value from monad or return a default."""
         raise NotImplementedError()
 
     @abstractmethod
-    def unwrap(self) -> ValueType:
+    def unwrap(self) -> ValueType:  # pragma: no cover
         """
         Custom magic method to unwrap inner value from monad.
 

poetry.lock

@@ -6,11 +6,11 @@ authors = ["sobolevn <mail@sobolevn.me>"]
 license = "MIT"
 
 [tool.poetry.dependencies]
-python = "^3.6"
+python = "^3.6 || ^3.7"
+typing-extensions = "^3.7"
 
 [tool.poetry.dev-dependencies]
 mypy = "^0.660.0"
-typing-extensions = "^3.7"
 attrs = "^18.2"
 wemake-python-styleguide = "^0.7.0"
 flake8-pytest = "^1.3"

pyproject.toml

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+from dry_monads.do_notation import do_notation
+from dry_monads.either import Either, Failure, Success
+
+
+@do_notation
+def _example(number: int) -> Either[int, str]:
+    first = Success(1).unwrap()
+    second = Failure('E').unwrap() if number % 2 else Success(number).unwrap()
+    return Success(first + second)
+
+
+def test_do_notation_success():
+    """Ensures that do notation works well for Success."""
+    assert _example(5) == Success(6)
+
+
+def test_do_notation_failure():
+    """Ensures that do notation works well for Failure."""
+    assert _example(6) == Failure('E')

tests/test_do_notation/test_do_notation.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from dry_monads.either import Left, Right
+from dry_monads.primitives.exceptions import UnwrapFailedError
+
+
+def test_unwrap_success():
+    """Ensures that left identity works for Right monad."""
+    assert Right(5).unwrap() == 5
+
+
+def test_unwrap_failure():
+    """Ensures that left identity works for Right monad."""
+    with pytest.raises(UnwrapFailedError):
+        assert Left(5).unwrap()