def from_iterable(
cls,
containers:
Iterable[
'RequiresContextIOResult[_EnvType, _ValueType, _ErrorType]',
],
) -> 'RequiresContextIOResult[_EnvType, Sequence[_ValueType], _ErrorType]':
"""
Transforms an iterable of ``RequiresContextIOResult`` containers.
Returns a single container with multiple elements inside.
.. code:: python
>>> from returns.context import RequiresContextIOResult
>>> from returns.io import IOSuccess, IOFailure
>>> assert RequiresContextIOResult.from_iterable([
... RequiresContextIOResult.from_value(1),
... RequiresContextIOResult.from_value(2),
... ])(...) == IOSuccess((1, 2))
>>> assert RequiresContextIOResult.from_iterable([
... RequiresContextIOResult.from_value(1),
... RequiresContextIOResult.from_failure('a'),
... ])(...) == IOFailure('a')
>>> assert RequiresContextIOResult.from_iterable([
... RequiresContextIOResult.from_failure('a'),
... RequiresContextIOResult.from_value(1),
... ])(...) == IOFailure('a')
"""
return iterable(cls, containers)
def from_iterable(
cls,
inner_value: Iterable['Result[_ValueType, _ErrorType]'],
) -> 'Result[Sequence[_ValueType], _ErrorType]':
"""
Transforms an iterable of ``Result`` containers into a single container.
.. code:: python
>>> from returns.result import Result, Success, Failure
>>> assert Result.from_iterable([
... Success(1),
... Success(2),
... ]) == Success((1, 2))
>>> assert Result.from_iterable([
... Success(1),
... Failure('a'),
... ]) == Failure('a')
>>> assert Result.from_iterable([
... Failure('a'),
... Success(1),
... ]) == Failure('a')
"""
return iterable(cls, inner_value)
def from_iterable(
cls,
inner_value: Iterable['IOResult[_ValueType, _ErrorType]'],
) -> 'IOResult[Sequence[_ValueType], _ErrorType]':
"""
Transforms an iterable of ``IOResult`` containers into a single one.
.. code:: python
>>> from returns.io import IOResult, IOSuccess, IOFailure
>>> assert IOResult.from_iterable([
... IOSuccess(1),
... IOSuccess(2),
... ]) == IOSuccess((1, 2))
>>> assert IOResult.from_iterable([
... IOSuccess(1),
... IOFailure('a'),
... ]) == IOFailure('a')
>>> assert IOResult.from_iterable([
... IOFailure('a'),
... IOSuccess(1),
... ]) == IOFailure('a')
"""
return iterable(cls, inner_value)
def from_iterable(
cls,
containers: Iterable['Maybe[_ValueType]'],
) -> 'Maybe[Sequence[_ValueType]]':
"""
Transforms an iterable of ``Maybe`` containers into a single container.
.. code:: python
>>> from returns.maybe import Maybe, Some, Nothing
>>> assert Maybe.from_iterable([
... Some(1),
... Some(2),
... ]) == Some((1, 2))
>>> assert Maybe.from_iterable([
... Some(1),
... Nothing,
... ]) == Nothing
>>> assert Maybe.from_iterable([
... Nothing,
... Some(1),
... ]) == Nothing
"""
return iterable(cls, containers)
def from_iterable(
cls,
containers: Iterable['FutureResult[_ValueType, _ErrorType]'],
) -> 'FutureResult[Sequence[_ValueType], _ErrorType]':
"""
Transforms an iterable of ``FutureResult`` containers.
Returns a single container with multiple elements inside.
.. code:: python
>>> import anyio
>>> from returns.future import FutureResult
>>> from returns.io import IOSuccess, IOFailure
>>> all_success = FutureResult.from_iterable([
... FutureResult.from_value(1),
... FutureResult.from_value(2),
... ])
>>> assert anyio.run(all_success.awaitable) == IOSuccess((1, 2))
>>> mixed = FutureResult.from_iterable([
... FutureResult.from_value(1),
... FutureResult.from_failure('a'),
... ])
>>> assert anyio.run(mixed.awaitable) == IOFailure('a')
>>> mixed = FutureResult.from_iterable([
... FutureResult.from_failure('a'),
... FutureResult.from_value(1),
... ])
>>> assert anyio.run(mixed.awaitable) == IOFailure('a')
"""
return iterable(cls, containers)
def from_iterable(
cls,
inner_value: Iterable['IO[_ValueType]'],
) -> 'IO[Sequence[_ValueType]]':
"""
Transforms an iterable of ``IO`` containers into a single container.
.. code:: python
>>> from returns.io import IO
>>> assert IO.from_iterable([
... IO(1),
... IO(2),
... ]) == IO((1, 2))
"""
return iterable(cls, inner_value)
def from_iterable(
cls,
inner_value: Iterable['RequiresContext[_EnvType, _ValueType]'],
) -> 'RequiresContext[Sequence[_ValueType], _EnvType]':
"""
Transforms an iterable of ``RequiresContext`` containers.
Returns a single container with a sequence of values.
.. code:: python
>>> from returns.context import RequiresContext
>>> assert RequiresContext.from_iterable([
... RequiresContext.from_value(1),
... RequiresContext.from_value(2),
... ])(...) == (1, 2)
"""
return iterable(cls, inner_value)
def from_iterable(
cls,
containers: Iterable['Future[_ValueType]'],
) -> 'Future[Sequence[_ValueType]]':
"""
Transforms an iterable of ``Future`` containers into a single container.
.. code:: python
>>> import anyio
>>> from returns.future import Future
>>> from returns.io import IO
>>> assert anyio.run(Future.from_iterable([
... Future.from_value(1),
... Future.from_value(2),
... ]).awaitable) == IO((1, 2))
"""
return iterable(cls, containers)
