add Partition #1905

CHANGELOG.md

@@ -14,9 +14,11 @@ See [0Ver](https://0ver.org/).
 - Improve inference of `ResultLike` objects when exception catching
   decorator is applied with explicit exception types
 - Add picky exceptions to `impure_safe` decorator like `safe` has. Issue #1543
+- Add partition function to result module. Issue #1905
 - Adds `default_error` parameter to `returns.converters.maybe_to_result`,
   which provides a default error value for `Failure`
 
+
 ### Misc
 
 - Now requires `mypy>=1.11`

docs/pages/methods.rst

@@ -76,6 +76,22 @@ Here's a full example:
   >>> error_handled = pointfree.bimap(lambda inr: inr + 1, lambda _: 0)(instance)
   >>> assert isinstance(methods.unwrap_or_failure(error_handled), int)
 
+partition
+~~~~~~~~~
+
+:func:`partition <returns.result.partition>` is used to convert
+list of :class:`~returns.interfaces.Unwrappable`
+instances like :class:`~returns.result.Result`,
+:class:`~returns.io.IOResult`, and :class:`~returns.maybe.Maybe`
+to a tuple of two lists: successes and failures.
+
+.. code:: python
+
+    >>> from returns.result import Failure, Success
+    >>> from returns.methods import partition
+    >>> results = [Success(1), Failure(2), Success(3), Failure(4)]
+    >>> partition(results)
+    ([1, 3], [2, 4])
 
 API Reference
 -------------

returns/methods/__init__.py

@@ -1,4 +1,5 @@
 from returns.methods.cond import cond as cond
+from returns.methods.partition import partition as partition
 from returns.methods.unwrap_or_failure import (
     unwrap_or_failure as unwrap_or_failure,
 )

returns/methods/partition.py

@@ -0,0 +1,38 @@
+
+from typing import Iterable, List, TypeVar
+
+from returns.interfaces.unwrappable import Unwrappable
+from returns.primitives.exceptions import UnwrapFailedError
+
+_ValueType = TypeVar('_ValueType', covariant=True)
+_ErrorType = TypeVar('_ErrorType', covariant=True)
+
+
+def partition(
+    containers: Iterable[
+        Unwrappable[_ValueType, _ErrorType],
+    ],
+) -> tuple[List[_ValueType], List[_ErrorType]]:
+    """
+    Partition a list of unwrappables into successful and failed values.
+
+    Preserves order.
+
+    .. code:: python
+
+        >>> from returns.result import Failure, Success
+        >>> from returns.methods import partition
+
+        >>> results = [Success(1), Failure(2), Success(3), Failure(4)]
+        >>> partition(results)
+        ([1, 3], [2, 4])
+
+    """
+    successes: list[_ValueType] = []
+    failures: list[_ErrorType] = []
+    for container in containers:
+        try:
+            successes.append(container.unwrap())
+        except UnwrapFailedError:
+            failures.append(container.failure())
+    return successes, failures

tests/test_methods/test_partition.py

@@ -0,0 +1,32 @@
+
+import pytest
+
+from returns.io import IO, IOResult
+from returns.maybe import Nothing, Some
+from returns.methods import partition
+from returns.result import Failure, Success
+
+
+@pytest.mark.parametrize(('containers', 'expected'), [
+    (
+        (Success(1), Success(2), Failure(None), Success(3)),
+        ([1, 2, 3], [None]),
+    ),
+    (
+        (
+            IOResult.from_value(1),
+            IOResult.from_failure(2),
+            IOResult.from_value(3),
+            IOResult.from_failure(4),
+        ),
+        ([IO(1), IO(3)], [IO(2), IO(4)]),
+    ),
+    (
+        (Some(1), Some(2), Nothing),
+        ([1, 2], [None]),
+    ),
+    ((), ([], [])),
+])
+def test_partition(containers, expected):
+    """Test partition function."""
+    assert partition(containers) == expected

typesafety/test_methods/test_partition.yml

@@ -0,0 +1,32 @@
+- case: partition_result
+  disable_cache: false
+  main: |
+    from typing import List
+    from returns.result import Success, Failure, Result
+    from returns.methods import partition
+
+    x: List[Result[int, str]]
+    reveal_type(partition(x))  # N: Revealed type is "Tuple[builtins.list[builtins.int], builtins.list[builtins.str]]"
+
+- case: partition_io_results
+  disable_cache: false
+  main: |
+    from typing import Tuple
+    from returns.result import Success, Failure
+    from returns.methods import partition
+    from returns.io import IO, IOResult, IOSuccess
+
+    x: Tuple[IOResult[int, str], IOResult[int, str]]
+    reveal_type(partition(x))  # N: Revealed type is "Tuple[builtins.list[returns.io.IO[builtins.int]], builtins.list[returns.io.IO[builtins.str]]]"
+
+- case: partition_maybe
+  disable_cache: false
+  main: |
+    from typing import List, Tuple
+    from returns.maybe import Maybe
+    from returns.methods import partition
+
+    x: List[Maybe[int]]
+
+    reveal_type(partition(x))  # N: Revealed type is "Tuple[builtins.list[builtins.int], builtins.list[None]]"
+