Closes #208, closes #201

sobolevn · sobolevn · commit 0bc229e3a14b · 2019-12-09T15:48:23.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,9 +8,18 @@ See (0Ver)[https://0ver.org/].
 
 ## 0.13.0
 
+### Features
+
+- Adds `io_squash` to squash several `IO` containers into one container with a tuple inside, currently works with `9` containers max at a time
+
 ### Bugfixes
 
 - Fixes that containers were not usable with `multiprocessing`
+- Changes the inheritance order, now `BaseContainer` is the first child
+
+### Misc
+
+- Now `generated` package is protected
 
 
 ## 0.12.0
diff --git a/docs/pages/io.rst b/docs/pages/io.rst
@@ -194,6 +194,34 @@ if :ref:`decorator_plugin <type-safety>` is used.
 This happens due to `mypy issue <https://github.com/python/mypy/issues/3157>`_.
 
 
+io_squash
+---------
+
+This function allows to squash several ``IO`` containers together.
+
+That's how it works:
+
+.. code:: python
+
+  from returns.io import IO, io_squash
+
+  io_squash(IO('first'), IO('second')) == IO(('first', 'second'))
+  # => revealed type of this instance is `IO[Tuple[str, str]]`
+
+It might be helpful if you want
+to work with mutliple ``IO`` instances at the same time.
+
+This approach saves you you from multiple nested ``IO.map`` calls.
+You can work with tuples instead like so:
+
+.. code:: python
+
+  io_squash(IO(1), IO(2)).map(lambda args: args[0] + args[1])
+  # => IO(3)
+
+We support up to 9 typed parameters to this function.
+
+
 unsafe_perform_io
 -----------------
 
diff --git a/returns/_generated/__init__.py b/returns/_generated/__init__.py
diff --git a/returns/_generated/box.py b/returns/_generated/box.py
diff --git a/returns/_generated/box.pyi b/returns/_generated/box.pyi
diff --git a/returns/_generated/coalesce.py b/returns/_generated/coalesce.py
diff --git a/returns/_generated/pipe.py b/returns/_generated/pipe.py
diff --git a/returns/_generated/pipe.pyi b/returns/_generated/pipe.pyi
@@ -40,7 +40,7 @@ def _pipe(
     ...
 
 
-@overload  # noqa: WPS211
+@overload
 def _pipe(
     p1: Callable[[_T1], _T2],
     p2: Callable[[_T2], _T3],
@@ -51,7 +51,7 @@ def _pipe(
     ...
 
 
-@overload  # noqa: WPS211
+@overload
 def _pipe(
     p1: Callable[[_T1], _T2],
     p2: Callable[[_T2], _T3],
@@ -63,7 +63,7 @@ def _pipe(
     ...
 
 
-@overload  # noqa: WPS211
+@overload
 def _pipe(
     p1: Callable[[_T1], _T2],
     p2: Callable[[_T2], _T3],
@@ -76,7 +76,7 @@ def _pipe(
     ...
 
 
-@overload  # noqa: WPS211
+@overload
 def _pipe(
     p1: Callable[[_T1], _T2],
     p2: Callable[[_T2], _T3],
diff --git a/returns/_generated/squash.py b/returns/_generated/squash.py
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+
+def _squash(*args):
+    """
+    Unwraps ``IO`` values, merges them into tuple, and wrapps back.
+
+    .. code:: python
+
+        >>> from returns.io import IO
+        >>> str(_squash(IO(1), IO(2)))
+        '<IO: (1, 2)>'
+
+    Also available as a class-method of ``IO`` container:
+
+    .. code:: python
+
+        >>> from returns.io import io_squash
+        >>> str(io_squash(IO('a'), IO('b')))
+        "<IO: ('a', 'b')>"
+
+    """
+    wrapper_class = type(args[0])
+    return wrapper_class(tuple(
+        container._inner_value  # noqa:  WPS437
+        for container in args
+    ))
diff --git a/returns/_generated/squash.pyi b/returns/_generated/squash.pyi
@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+
+from typing import Tuple, TypeVar, overload
+
+from returns.io import IO
+
+_T1 = TypeVar('_T1')
+_T2 = TypeVar('_T2')
+_T3 = TypeVar('_T3')
+_T4 = TypeVar('_T4')
+_T5 = TypeVar('_T5')
+_T6 = TypeVar('_T6')
+_T7 = TypeVar('_T7')
+_T8 = TypeVar('_T8')
+_T9 = TypeVar('_T9')
+
+
+@overload
+def _squash(
+    p1: IO[_T1],
+    p2: IO[_T2],
+) -> IO[Tuple[_T1, _T2]]:
+    ...
+
+
+@overload
+def _squash(
+    p1: IO[_T1],
+    p2: IO[_T2],
+    p3: IO[_T3],
+) -> IO[Tuple[_T1, _T2, _T3]]:
+    ...
+
+
+@overload
+def _squash(
+    p1: IO[_T1],
+    p2: IO[_T2],
+    p3: IO[_T3],
+    p4: IO[_T4],
+) -> IO[Tuple[_T1, _T2, _T3, _T4]]:
+    ...
+
+
+@overload
+def _squash(
+    p1: IO[_T1],
+    p2: IO[_T2],
+    p3: IO[_T3],
+    p4: IO[_T4],
+    p5: IO[_T5],
+) -> IO[Tuple[_T1, _T2, _T3, _T4, _T5]]:
+    ...
+
+
+@overload
+def _squash(
+    p1: IO[_T1],
+    p2: IO[_T2],
+    p3: IO[_T3],
+    p4: IO[_T4],
+    p5: IO[_T5],
+    p6: IO[_T6],
+) -> IO[Tuple[_T1, _T2, _T3, _T4, _T5, _T6]]:
+    ...
+
+
+@overload
+def _squash(
+    p1: IO[_T1],
+    p2: IO[_T2],
+    p3: IO[_T3],
+    p4: IO[_T4],
+    p5: IO[_T5],
+    p6: IO[_T6],
+    p7: IO[_T7],
+) -> IO[Tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7]]:
+    ...
+
+
+@overload
+def _squash(
+    p1: IO[_T1],
+    p2: IO[_T2],
+    p3: IO[_T3],
+    p4: IO[_T4],
+    p5: IO[_T5],
+    p6: IO[_T6],
+    p7: IO[_T7],
+    p8: IO[_T8],
+) -> IO[Tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8]]:
+    ...
+
+
+@overload
+def _squash(
+    p1: IO[_T1],
+    p2: IO[_T2],
+    p3: IO[_T3],
+    p4: IO[_T4],
+    p5: IO[_T5],
+    p6: IO[_T6],
+    p7: IO[_T7],
+    p8: IO[_T8],
+    p9: IO[_T9],
+) -> IO[Tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9]]:
+    ...
diff --git a/returns/converters.py b/returns/converters.py
@@ -2,7 +2,7 @@
 
 from typing import TypeVar, overload
 
-from returns.generated import coalesce
+from returns._generated import coalesce  # noqa: WPS436
 from returns.io import IO
 from returns.maybe import Maybe
 from returns.result import Failure, Result, Success
diff --git a/returns/functions.py b/returns/functions.py
@@ -2,7 +2,7 @@
 
 from typing import Any, Callable, NoReturn, TypeVar
 
-from returns.generated.box import _box as box  # noqa: F401, WPS436
+from returns._generated.box import _box as box  # noqa: F401, WPS436
 
 # Aliases:
 _FirstType = TypeVar('_FirstType')
diff --git a/returns/io.py b/returns/io.py
@@ -6,6 +6,7 @@
 
 from typing_extensions import final
 
+from returns._generated.squash import _squash as io_squash  # noqa: F401, WPS436
 from returns.primitives.container import BaseContainer
 
 _ValueType = TypeVar('_ValueType', covariant=True)
@@ -17,7 +18,7 @@
 
 
 @final
-class IO(Generic[_ValueType], BaseContainer):
+class IO(BaseContainer, Generic[_ValueType]):
     """
     Explicit marker for impure function results.
 
@@ -33,7 +34,7 @@ class IO(Generic[_ValueType], BaseContainer):
 
     def __init__(self, inner_value: _ValueType) -> None:
         """Required for typing."""
-        BaseContainer.__init__(self, inner_value)  # noqa: WPS609
+        super().__init__(inner_value)
 
     def map(  # noqa: A003
         self,
diff --git a/returns/maybe.py b/returns/maybe.py
@@ -32,8 +32,8 @@
 
 
 class Maybe(
-    Generic[_ValueType],
     BaseContainer,
+    Generic[_ValueType],
     metaclass=ABCMeta,
 ):
     """
@@ -107,11 +107,11 @@ class _Nothing(Maybe[Any]):
 
     def __init__(self, inner_value: None = None) -> None:
         """
-        Wraps the given value in the Container.
+        Wraps the given value in the ``Nothing`` container.
 
         ``inner_value`` can only be ``None``.
         """
-        BaseContainer.__init__(self, inner_value)  # noqa: WPS609
+        super().__init__(None)
 
     def __str__(self):
         """Custom str definition without state inside."""
@@ -236,7 +236,7 @@ class _Some(Maybe[_ValueType]):
 
     def __init__(self, inner_value: _ValueType) -> None:
         """Required for typing."""
-        BaseContainer.__init__(self, inner_value)  # noqa: WPS609
+        super().__init__(inner_value)
 
     def map(self, function):  # noqa: A003
         """
diff --git a/returns/pipeline.py b/returns/pipeline.py
@@ -4,7 +4,7 @@
 from inspect import iscoroutinefunction
 from typing import Callable, Coroutine, TypeVar, Union, overload
 
-from returns.generated.pipe import _pipe as pipe  # noqa: F401, WPS436
+from returns._generated.pipe import _pipe as pipe  # noqa: F401, WPS436
 from returns.maybe import Maybe
 from returns.primitives.exceptions import UnwrapFailedError
 from returns.result import Result
diff --git a/returns/result.py b/returns/result.py
@@ -34,8 +34,8 @@
 
 
 class Result(
-    Generic[_ValueType, _ErrorType],
     BaseContainer,
+    Generic[_ValueType, _ErrorType],
     metaclass=ABCMeta,
 ):
     """
@@ -128,7 +128,7 @@ class _Failure(Result[Any, _ErrorType]):
 
     def __init__(self, inner_value: _ErrorType) -> None:
         """Required for typing."""
-        BaseContainer.__init__(self, inner_value)  # noqa: WPS609
+        super().__init__(inner_value)
 
     def map(self, function):  # noqa: A003
         """
@@ -272,7 +272,7 @@ class _Success(Result[_ValueType, Any]):
 
     def __init__(self, inner_value: _ValueType) -> None:
         """Required for typing."""
-        BaseContainer.__init__(self, inner_value)  # noqa: WPS609
+        super().__init__(inner_value)
 
     def map(self, function):  # noqa: A003
         """
diff --git a/setup.cfg b/setup.cfg
@@ -43,6 +43,8 @@ per-file-ignores =
   returns/*.py: D104
   # Disable imports in `__init__.py`:
   returns/__init__.py: F401, WPS412
+  # Some generated code:
+  returns/_generated/*.pyi: WPS211, WPS428
   # There are multiple assert's in tests:
   tests/*.py: S101, WPS226, WPS432, WPS436
   # Annotations:
diff --git a/tests/test_io/test_io_squash.py b/tests/test_io/test_io_squash.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+from returns.io import IO, io_squash
+
+
+def test_io_squash():
+    """Tests that squash works correctly."""
+    assert io_squash(
+        IO('a'), IO('b'),
+    ) == IO(('a', 'b'))
+
+    assert io_squash(
+        IO(1), IO(2), IO(3),
+    ) == IO((1, 2, 3))
+
+    assert io_squash(
+        IO(1), IO(2), IO('3'), IO(4),
+    ) == IO((1, 2, '3', 4))
diff --git a/typesafety/test_io_types/test_io_squash.yml b/typesafety/test_io_types/test_io_squash.yml
@@ -0,0 +1,22 @@
+- case: io_squash2
+  disable_cache: true
+  main: |
+    from returns.io import IO, io_squash
+
+    reveal_type(io_squash(IO(1), IO('a')))  # N: Revealed type is 'returns.io.IO[Tuple[builtins.int*, builtins.str*]]'
+
+
+- case: io_squash3
+  disable_cache: true
+  main: |
+    from returns.io import IO, io_squash
+
+    reveal_type(io_squash(IO(1), IO('a'), IO(False)))  # N: Revealed type is 'returns.io.IO[Tuple[builtins.int*, builtins.str*, builtins.bool*]]'
+
+
+- case: io_squash4
+  disable_cache: true
+  main: |
+    from returns.io import IO, io_squash
+
+    reveal_type(io_squash(IO(1), IO('a'), IO(False), IO(2)))  # N: Revealed type is 'returns.io.IO[Tuple[builtins.int*, builtins.str*, builtins.bool*, builtins.int*]]'
