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,20 @@ 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.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,37 @@
+
+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 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: 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_result/test_result_methods.py

@@ -0,0 +1,30 @@
+
+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)),
+ ([1, 2], [None]),
+ ),
+ (
+ (
+ IOResult.from_value(1),
+ IOResult.from_value(2),
+ IOResult.from_failure(None),
+ ),
+ ([IO(1), IO(2)], [IO(None)]),
+ ),
+ (
+ (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_no_params
+ 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]]"
+