Merges types and code

Author: sobolevn

CHANGELOG.md

@@ -21,8 +21,10 @@ We follow Semantic Versions since the `0.1.0` release.
 
 ### Misc
 
+- Reapplied all types to `.py` files
 - Improved docs about `IO` and `Container` concept
 - Adds docs about container composition
+- Moves from `Alpha` to `Beta`
 
 
 ## 0.7.0

poetry.lock

@@ -24,7 +24,7 @@ keywords = [
 ]
 
 classifiers = [
-  "Development Status :: 3 - Alpha",
+  "Development Status :: 4 - Beta",
   "Intended Audience :: Developers",
   "Operating System :: OS Independent",
   "Topic :: Software Development :: Libraries :: Python Modules",
@@ -39,7 +39,6 @@ typing-extensions = "^3.7"
 mypy = "^0.701"
 wemake-python-styleguide = "^0.8.1"
 flake8-pytest = "^1.3"
-flake8-pyi = "^19.2"
 
 safety = "^1.8"
 

pyproject.toml

@@ -1,15 +1,24 @@
 # -*- coding: utf-8 -*-
 
+from typing import TypeVar
+
 from returns.maybe import Maybe
-from returns.result import Failure, Success
+from returns.result import Failure, Result, Success
+
+_ValueType = TypeVar('_ValueType')
+_ErrorType = TypeVar('_ErrorType')
 
 
-def result_to_maybe(result_container):
+def result_to_maybe(
+    result_container: Result[_ValueType, _ErrorType],
+) -> Maybe[_ValueType]:
     """Converts ``Result`` container to ``Maybe`` container."""
     return Maybe.new(result_container.value_or(None))
 
 
-def maybe_to_result(maybe_container):
+def maybe_to_result(
+    maybe_container: Maybe[_ValueType],
+) -> Result[_ValueType, None]:
     """Converts ``Maybe`` container to ``Result`` container."""
     inner_value = maybe_container.value_or(None)
     if inner_value is not None:

returns/converters.py

@@ -1,7 +1,17 @@
 # -*- coding: utf-8 -*-
 
+from typing import Callable, NoReturn, TypeVar
 
-def compose(first, second):
+# Just aliases:
+_FirstType = TypeVar('_FirstType')
+_SecondType = TypeVar('_SecondType')
+_ThirdType = TypeVar('_ThirdType')
+
+
+def compose(
+    first: Callable[[_FirstType], _SecondType],
+    second: Callable[[_SecondType], _ThirdType],
+) -> Callable[[_FirstType], _ThirdType]:
     """
     Allows function composition.
 
@@ -22,7 +32,7 @@ def compose(first, second):
     return lambda argument: second(first(argument))
 
 
-def raise_exception(exception):
+def raise_exception(exception: Exception) -> NoReturn:
     """
     Helper function to raise exceptions as a function.
 

returns/converters.pyi

@@ -2,13 +2,21 @@
 
 from functools import wraps
 from inspect import iscoroutinefunction
-from typing import TypeVar
+from typing import Callable, Coroutine, TypeVar, overload
 
-from returns.primitives.container import GenericContainerOneSlot
+from typing_extensions import final
+
+from returns.primitives.container import Container, GenericContainerOneSlot
 
 _ValueType = TypeVar('_ValueType')
+_NewValueType = TypeVar('_NewValueType')
+
+# Helpers:
+_FirstType = TypeVar('_FirstType')
+_SecondType = TypeVar('_SecondType')
 
 
+@final
 class IO(GenericContainerOneSlot[_ValueType]):
     """
     Explicit marker for impure function results.
@@ -21,7 +29,16 @@ class IO(GenericContainerOneSlot[_ValueType]):
     There's no way to directly get its internal value.
     """
 
-    def map(self, function):  # noqa: A003
+    _inner_value: _ValueType
+
+    def __init__(self, inner_value: _ValueType) -> None:
+        """Required for typing."""
+        Container.__init__(self, inner_value)  # type: ignore # noqa: Z462
+
+    def map(  # noqa: A003
+        self,
+        function: Callable[[_ValueType], _NewValueType],
+    ) -> 'IO[_NewValueType]':
         """
         Applies function to the inner value.
 
@@ -32,7 +49,9 @@ def map(self, function):  # noqa: A003
         """
         return IO(function(self._inner_value))
 
-    def bind(self, function):
+    def bind(
+        self, function: Callable[[_ValueType], 'IO[_NewValueType]'],
+    ) -> 'IO[_NewValueType]':
         """
         Applies 'function' to the result of a previous calculation.
 
@@ -42,6 +61,23 @@ def bind(self, function):
         return function(self._inner_value)
 
 
+@overload
+def impure(  # type: ignore
+    function: Callable[..., Coroutine[_FirstType, _SecondType, _NewValueType]],
+) -> Callable[
+    ...,
+    Coroutine[_FirstType, _SecondType, IO[_NewValueType]],
+]:
+    """Case for async functions."""
+
+
+@overload
+def impure(
+    function: Callable[..., _NewValueType],
+) -> Callable[..., IO[_NewValueType]]:
+    """Case for regular functions."""
+
+
 def impure(function):
     """
     Decorator to mark function that it returns :py:class:`IO` container.