Removes monad refernce

Author: sobolevn

CHANGELOG.md

@@ -3,6 +3,14 @@
 We follow Semantic Versions since the `0.1.0` release.
 
 
+## WIP
+
+### Misc
+
+- Changes how `str()` function works for container types
+- Total rename to "container" in the source code
+
+
 ## Version 0.6.0
 
 ### Features

returns/functions.py

@@ -24,7 +24,7 @@ def is_successful(container):
 
 def safe(function):  # noqa: C901
     """
-    Decorator to covert exception throwing function to 'Result' monad.
+    Decorator to covert exception throwing function to 'Result' container.
 
     Show be used with care, since it only catches 'Exception' subclasses.
     It does not catch 'BaseException' subclasses.

returns/primitives/container.py

@@ -23,16 +23,16 @@ def __init__(self, inner_value):
         object.__setattr__(self, '_inner_value', inner_value)
 
     def __setattr__(self, attr_name, attr_value):
-        """Makes inner state of the monads immutable."""
+        """Makes inner state of the containers immutable."""
         raise ImmutableStateError()
 
     def __delattr__(self, attr_name):  # noqa: Z434
-        """Makes inner state of the monads immutable."""
+        """Makes inner state of the containers immutable."""
         raise ImmutableStateError()
 
     def __str__(self):
         """Converts to string."""
-        return '{0}: {1}'.format(
+        return '<{0}: {1}>'.format(
             self.__class__.__qualname__,
             str(self._inner_value),
         )
@@ -52,9 +52,9 @@ class Container(_BaseContainer, metaclass=ABCMeta):
 
     You won't create 'Container' instances directly.
     Instead, sub-classes implement specific contexts.
-    Monads allow you to bind together
+    containers allow you to bind together
     a series of calculations while maintaining
-    the context of that specific monad.
+    the context of that specific container.
 
     This is an abstract class with the API declaration.
 
@@ -69,7 +69,7 @@ def map(self, function):  # pragma: no cover
         Applies 'function' to the contents of the functor.
 
         And returns a new functor value.
-        Works for monads that represent success.
+        Works for containers that represent success.
         Is the opposite of :meth:`~fix`.
         """
         raise NotImplementedError()
@@ -79,8 +79,8 @@ def bind(self, function):  # pragma: no cover
         """
         Applies 'function' to the result of a previous calculation.
 
-        And returns a new monad.
-        Works for monads that represent success.
+        And returns a new container.
+        Works for containers that represent success.
         Is the opposite of :meth:`~rescue`.
         """
         raise NotImplementedError()
@@ -91,7 +91,7 @@ def fix(self, function):  # pragma: no cover
         Applies 'function' to the contents of the functor.
 
         And returns a new functor value.
-        Works for monads that represent failure.
+        Works for containers that represent failure.
         Is the opposite of :meth:`~map`.
         """
         raise NotImplementedError()
@@ -101,21 +101,21 @@ def rescue(self, function):  # pragma: no cover
         """
         Applies 'function' to the result of a previous calculation.
 
-        And returns a new monad.
-        Works for monads that represent failure.
+        And returns a new container.
+        Works for containers that represent failure.
         Is the opposite of :meth:`~bind`.
         """
         raise NotImplementedError()
 
     @abstractmethod
     def value_or(self, default_value):  # pragma: no cover
-        """Forces to unwrap value from monad or return a default."""
+        """Forces to unwrap value from container or return a default."""
         raise NotImplementedError()
 
     @abstractmethod
     def unwrap(self):  # pragma: no cover
         """
-        Custom magic method to unwrap inner value from monad.
+        Custom magic method to unwrap inner value from container.
 
         Should be redefined for ones that actually have values.
         And for ones that raise an exception for no values.
@@ -127,7 +127,7 @@ def unwrap(self):  # pragma: no cover
     @abstractmethod
     def failure(self):  # pragma: no cover
         """
-        Custom magic method to unwrap inner value from the failed monad.
+        Custom magic method to unwrap inner value from the failed container.
 
         This method is the opposite of :meth:`~unwrap`.
         """
@@ -136,7 +136,7 @@ def failure(self):  # pragma: no cover
 
 class GenericContainerOneSlot(Generic[_ValueType], Container):
     """
-    Base class for monads with one typed slot.
+    Base class for containers with one typed slot.
 
     Use this type for generic inheritance only.
     Use :class:`~Container` as a general type for polymorphism.
@@ -145,7 +145,7 @@ class GenericContainerOneSlot(Generic[_ValueType], Container):
 
 class GenericContainerTwoSlots(Generic[_ValueType, _ErrorType], Container):
     """
-    Base class for monads with two typed slot.
+    Base class for containers with two typed slot.
 
     Use this type for generic inheritance only.
     Use :class:`~Container` as a general type for polymorphism.

returns/result.py

@@ -39,16 +39,16 @@ def fix(self, function):
 
         Applies 'function' to the contents of the 'Success' instance
         and returns a new 'Success' object containing the result.
-        'function' should accept a single "normal" (non-monad) argument
-        and return a non-monad result.
+        'function' should accept a single "normal" (non-container) argument
+        and return a non-container result.
         """
         return Success(function(self._inner_value))
 
     def rescue(self, function):
         """
         Applies 'function' to the result of a previous calculation.
 
-        'function' should accept a single "normal" (non-monad) argument
+        'function' should accept a single "normal" (non-container) argument
         and return Result a 'Failure' or 'Success' type object.
         """
         return function(self._inner_value)
@@ -65,7 +65,7 @@ def unwrap(self):
         raise UnwrapFailedError(self)
 
     def failure(self):
-        """Unwraps inner error value from failed monad."""
+        """Unwraps inner error value from failed container."""
         return self._inner_value
 
 
@@ -82,16 +82,16 @@ def map(self, function):  # noqa: A003
 
         Applies 'function' to the contents of the 'Success' instance
         and returns a new 'Success' object containing the result.
-        'function' should accept a single "normal" (non-monad) argument
-        and return a non-monad result.
+        'function' should accept a single "normal" (non-container) argument
+        and return a non-container result.
         """
         return Success(function(self._inner_value))
 
     def bind(self, function):
         """
         Applies 'function' to the result of a previous calculation.
 
-        'function' should accept a single "normal" (non-monad) argument
+        'function' should accept a single "normal" (non-container) argument
         and return Result a 'Failure' or 'Success' type object.
         """
         return function(self._inner_value)
@@ -109,7 +109,7 @@ def value_or(self, default_value):
         return self._inner_value
 
     def unwrap(self):
-        """Returns the unwrapped value from the inside of this monad."""
+        """Returns the unwrapped value from the inside of this container."""
         return self._inner_value
 
     def failure(self):

tests/test_result/test_result_bind.py

@@ -12,7 +12,7 @@ def factory(inner_value: int) -> Success[int]:
     bound = Success(input_value).bind(factory)
 
     assert bound == factory(input_value)
-    assert str(bound) == 'Success: 10'
+    assert str(bound) == '<Success: 10>'
 
 
 def test_left_identity_failure():
@@ -24,7 +24,7 @@ def factory(inner_value: int) -> Failure[TypeError]:
     bound = Failure(input_value).bind(factory)
 
     assert bound == Failure(input_value)
-    assert str(bound) == 'Failure: 5'
+    assert str(bound) == '<Failure: 5>'
 
 
 def test_rescue_success():
@@ -35,7 +35,7 @@ def factory(inner_value: int) -> Success[int]:
     bound = Success(5).rescue(factory)
 
     assert bound == Success(5)
-    assert str(bound) == 'Success: 5'
+    assert str(bound) == '<Success: 5>'
 
 
 def test_rescue_failure():
@@ -47,4 +47,4 @@ def factory(inner_value: int) -> Failure[float]:
     bound = Failure(5).rescue(factory)
 
     assert bound == Failure(expected)
-    assert str(bound) == 'Failure: 6.0'
+    assert str(bound) == '<Failure: 6.0>'