IOSuccess(2)],
IOFailure('a'),
),
([IOSuccess(1), IOFailure('a')], IOFailure('a')),
([IOFailure('a'), IOFailure('b')], IOFailure('a')),
])
def test_fold_collect(iterable, sequence):
"""Iterable for regular types and ``Fold``."""
assert Fold.collect(iterable, sequence.from_value(())) == sequence
@pytest.mark.parametrize(
('iterable', 'sequence'),
[
# Regular types:
([], Reader.from_value(())),
([Reader.from_value(1)], Reader.from_value((1, ))),
(
[Reader.from_value(1), Reader.from_value(2)],
Reader.from_value((1, 2)),
),
# Can fail:
([], ReaderResult.from_value(())),
([ReaderResult.from_value(1)], ReaderResult.from_value((1, ))),
(
[ReaderResult.from_value(1),
ReaderResult.from_value(2)],
ReaderResult.from_value((1, 2)),
),
(
from returns.primitives.container import BaseContainer
from returns.result import Result
_containers: Sequence[BaseContainer] = (
Result.from_failure(1),
Result.from_value(1),
IO(1),
IOResult.from_failure(1),
IOResult.from_value(1),
Maybe.from_value(1),
Maybe.from_value(None),
Maybe.from_optional(None),
Future.from_value(1),
FutureResult.from_value(1),
FutureResult.from_failure(1),
Reader.from_value(1),
ReaderResult.from_value(1),
ReaderResult.from_failure(1),
ReaderIOResult.from_value(1),
ReaderIOResult.from_failure(1),
ReaderFutureResult.from_value(1),
ReaderFutureResult.from_failure(1),
)
@pytest.mark.parametrize('container', _containers)
def test_assert_equal(container, anyio_backend_name: str):
"""Ensure that containers can be equal."""
assert_equal(container, container, backend=anyio_backend_name)
def test_collect_all_reader(iterable, sequence):
"""Iterable for ``Reader`` and ``CollectAll``."""
assert Reader.from_iterable(iterable, CollectAll)(...) == sequence(...)
[IOFailure('a'), IOSuccess(1),
IOSuccess(2)],
IOFailure('a'),
),
([IOFailure('a'), IOFailure('b')], IOFailure('a')),
])
def test_fold_loop(iterable, sequence):
"""Iterable for ``Result`` and ``FailFast``."""
assert Fold.loop(iterable, sequence.from_value(10), _sum_two) == sequence
@pytest.mark.parametrize(
('iterable', 'sequence'),
[
# Regular types:
([], Reader.from_value(10)),
([Reader.from_value(1)], Reader.from_value(11)),
(
[Reader.from_value(1), Reader.from_value(2)],
Reader.from_value(13),
),
# Can fail:
([], ReaderResult.from_value(10)),
([ReaderResult.from_value(1)], ReaderResult.from_value(11)),
(
[ReaderResult.from_value(1),
ReaderResult.from_value(2)],
ReaderResult.from_value(13),
),
(
def test_fail_fast_reader(iterable, sequence):
"""Iterable for ``Reader`` and ``FailFast``."""
assert Reader.from_iterable(iterable, FailFast)(...) == sequence(...)