Closes #256

Author: sobolevn

CHANGELOG.md

@@ -15,6 +15,8 @@ See [0Ver](https://0ver.org/).
 - **Breaking**: removes `Maybe.rescue` and `Maybe.fix` methods
 - **Breaking**: renames `io_squash` to `squash_io`
   and moves it to `returns.converters`
+- **Breaking**: moves all interfaces from `returns.primitives.container` to
+  `returns.primitives.interfaces`
 
 - Adds `rescue` pointfree function
 - Adds `ResultE` alias for `Result[..., Exception]`
@@ -47,14 +49,17 @@ See [0Ver](https://0ver.org/).
 
 - Adds `Result.lift`, `Maybe.lift`, `RequiresContext.lift`,
   and `RequiresContextResult.lift` functions in addition to `IO.lift`
+
 - Adds `Immutable` primitive type
 - Adds `Unitable` protocol and `.from_success()` and `.from_failure()`
   methods for all `Result` realted classes
+- Adds `Instanceable` protocol and `.from_value()` method
+  for `IO` and `RequiresContext`
+
 - Adds `flow` function, which is similar to `pipe`
 - Adds `swap` coverter for `Result` and `IOResult`
 - Adds `squash_context` function to squash `RequiresContext` similar to `IO`
 
-
 ### Bugfixes
 
 - Now `Success` and `Failure` (both `io` and pure) return `Any` and not `NoReturn`

returns/context/requires_context.py

@@ -221,6 +221,8 @@ def from_value(
 
         Might be used with or without direct type hint.
 
+        Part of the :class:`returns.primitives.interfaces.Instanceable`
+        protocol.
         """
         return RequiresContext(lambda _: inner_value)
 

returns/io.py

@@ -149,6 +149,23 @@ def lift(
         """
         return lambda container: container.map(function)
 
+    @classmethod
+    def from_value(cls, inner_value: _NewValueType) -> 'IO[_NewValueType]':
+        """
+        Unit function to construct new ``IO`` values.
+
+        Is the same as regular constructor:
+
+        .. code:: python
+
+          >>> from returns.io import IO
+          >>> assert IO(1) == IO.from_value(1)
+
+        Part of the :class:`returns.primitives.interfaces.Instanceable`
+        protocol.
+        """
+        return IO(inner_value)
+
 
 # Helper functions:
 

returns/primitives/interfaces.py

@@ -136,6 +136,22 @@ def alt(
         """
 
 
+@runtime
+class Instanceable(Protocol[_ValueType]):
+    """
+    Allows to create unit containers from raw values.
+
+    This is heavily related to classes that do not have conunter-parts.
+    Like ``IO`` and ``RequiresContext``.
+    """
+
+    @classmethod
+    def from_value(
+        cls, inner_value: _NewValueType,
+    ) -> 'Unitable[_NewValueType, Any]':
+        """This method is required to create new containers."""
+
+
 @runtime
 class Unitable(Protocol[_ValueType, _ErrorType]):
     """

tests/test_context/test_requires_context/test_context.py

@@ -4,7 +4,7 @@
 
 from returns.context import Context, RequiresContext
 from returns.primitives.exceptions import ImmutableStateError
-from returns.primitives.interfaces import Bindable, Mappable
+from returns.primitives.interfaces import Bindable, Instanceable, Mappable
 
 
 @pytest.mark.parametrize('container', [
@@ -15,6 +15,7 @@
 @pytest.mark.parametrize('protocol', [
     Bindable,
     Mappable,
+    Instanceable,
 ])
 def test_protocols(container, protocol):
     """Ensures that RequiresContext has all the right protocols."""

tests/test_io/test_io_container/test_io.py

@@ -3,7 +3,7 @@
 import pytest
 
 from returns.io import IO
-from returns.primitives.interfaces import Bindable, Mappable
+from returns.primitives.interfaces import Bindable, Instanceable, Mappable
 
 
 @pytest.mark.parametrize('container', [
@@ -12,6 +12,7 @@
 @pytest.mark.parametrize('protocol', [
     Bindable,
     Mappable,
+    Instanceable,
 ])
 def test_protocols(container, protocol):
     """Ensures that IO has all the right protocols."""

typesafety/test_context/test_requires_context/test_requires_context_cast.yml

@@ -18,3 +18,34 @@
     second: RequiresContext[Exception, Exception] = first
   out: |
     main:4: error: Incompatible types in assignment (expression has type "RequiresContext[ValueError, TypeError]", variable has type "RequiresContext[Exception, Exception]")
+
+
+- case: context_covariant_cast
+  disable_cache: true
+  main: |
+    from returns.context import RequiresContext
+
+    class A(object):
+        a = 1
+
+    class B(A):
+        b = 2
+
+    class C(A):
+        c = 3
+
+    def func() -> RequiresContext[B, int]:
+        return RequiresContext(lambda deps: deps.a + deps.b)
+
+    def second(a: int) -> RequiresContext[A, int]:
+        return RequiresContext(lambda deps: deps.a + a)
+
+    def third(a: int) -> RequiresContext[C, int]:
+        return RequiresContext(lambda deps: deps.c + a)
+
+    reveal_type(func().bind(second))
+    reveal_type(func().bind(third))
+  out: |
+    main:21: note: Revealed type is 'returns.context.requires_context.RequiresContext[main.B, builtins.int*]'
+    main:22: error: Argument 1 to "bind" of "RequiresContext" has incompatible type "Callable[[int], RequiresContext[C, int]]"; expected "Callable[[int], RequiresContext[B, int]]"
+    main:22: note: Revealed type is 'returns.context.requires_context.RequiresContext[main.B, builtins.int*]'