add Partition #1905

CHANGELOG.md

@@ -14,6 +14,7 @@ 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
 
 ### Misc
 

docs/pages/result.rst

@@ -138,6 +138,19 @@ argument that lead to that exception.
 
   This decorator works only with functions that has just one argument.
 
+partition
+~~~~~~~
+
+:func:`partition <returns.result.partition>` is used to convert
+list of ``Result`` instances to a tuple of two lists: successes and failures.
+  .. code:: python
+
+      >>> from returns.result import Failure, Success
+      >>> from returns.result.methods import partition
+      >>> results = [Success(1), Failure(2), Success(3), Failure(4)]
+      >>> partition(results)
+      ([1, 3], [2, 4])
+
 FAQ
 ---
 

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.specific import result
+from returns.primitives.exceptions import UnwrapFailedError
+
+_ValueType = TypeVar('_ValueType', covariant=True)
+_ErrorType = TypeVar('_ErrorType', covariant=True)
+_AdditionalType = TypeVar('_AdditionalType')
+
+
+def partition(
+    containers: Iterable[
+        result.ResultBasedN[_ValueType, _ErrorType, _AdditionalType]
+    ],
+) -> tuple[List[_ValueType], List[_ErrorType]]:
+    """
+    Partition a list of results into successful and failed unwrapped 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 = []
+    failures = []
+    for container in containers:
+        try:
+            successes.append(container.unwrap())
+        except UnwrapFailedError:
+            failures.append(container.failure())
+    return successes, failures

tests/test_result/test_result_partition.py

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

typesafety/test_result/test_partition.yml

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