def test_to_union() -> None: # The point of this test is to ensure that mypy's type inference works # properly, ergo we prefer to not parametrize it. def foo(x: Union[int, str]) -> bool: return isinstance(x, int) or isinstance(x, str) e: Either[int, str] = Left(42) assert e.to_union() == 42 assert foo(e.to_union()) e = Right("hello") assert e.to_union() == "hello" assert foo(e.to_union()) # mypy should properly unify Union[NoReturn, X] for all types X. assert Either.left(42).to_union() + 1 == 43 assert len(Either.right("hello").to_union()) == len("hello")
def test_zio_effect_catch_1() -> None: x: Optional[int] = None def _impure_function() -> int: nonlocal x x = 100 return 42 program = ZIO.effect_catch(_impure_function, Bippy) assert x is None assert program._run(()) == Right(42) assert x == 100
def test_zio_map_1() -> None: count = 0 def _impure_function(x: int) -> int: nonlocal count count += 1 return x + 1 assert (ZIO.succeed(100).map(_impure_function).map(_impure_function).map( _impure_function).map(lambda x: f"The result is: {x}")._run( ())) == Right("The result is: 103") assert count == 3
def test_zio_flatten_1() -> None: count = 0 def _impure_function(x: int) -> ZIO[object, NoReturn, int]: nonlocal count count += 1 return ZIO.succeed(x + 1) assert (ZIO.succeed(100).flat_map(_impure_function).flat_map( _impure_function).flat_map(_impure_function).map( lambda x: ZIO.succeed(f"The result is: {x}")).flatten()._run( ())) == Right("The result is: 103") assert count == 3
def test_zio_either_2() -> None: assert ZIO.fail("a").either()._run(()) == Right(Left("a"))
def test_zio_or_die_1() -> None: assert ZIO.succeed(42).or_die()._run(()) == Right(42)
def succeed(a: AA) -> "ZIO[object, NoReturn, AA]": return ZIO(lambda _: Right(a))
def test_zio_either_1() -> None: assert ZIO.succeed("a").either()._run(()) == Right(Right("a"))
@pytest.mark.parametrize("input,expected", [ (42, Left(42)), ("asdf", Left("asdf")), ]) def test_either_left(input: Either[A, NoReturn], expected: Left[A]) -> None: x = Either.left(input) assert x == x.to_left() == expected with pytest.raises(TypeError): x.to_right() # type: ignore @pytest.mark.parametrize("input,expected", [ (42, Right(42)), ("asdf", Right("asdf")), ]) def test_either_right(input: Either[A, NoReturn], expected: Right[A]) -> None: x = Either.right(input) assert x == x.to_right() == expected with pytest.raises(TypeError): x.to_left() # type: ignore @pytest.mark.parametrize("value,left_type,right_type", [(42, int, str), ("asdf", str, int)]) def test_from_union_left(value: Union[A, B], left_type: Type[A], right_type: Type[B]) -> None: assert Either.from_union(value, left_type,
def test_raise_errors_no_errors() -> None: assert Either.right("hello").raise_errors() == Right("hello")
def test_zio_provide() -> None: assert (ZIO(Right[int]).map(lambda x: x + 1).map(lambda x: x + 1).map( lambda x: x + 1).provide(100)._run(())) == Right(103)
def test_zio_succeed() -> None: assert ZIO.succeed(42)._run(()) == Right(42)
def test_zio_access() -> None: accessor: Callable[[str], int] = len assert ZIO.access(accessor)._run("hello") == Right(5)
def test_zio_access_m_1() -> None: accessor: Callable[[str], ZIO[object, NoReturn, int]] = lambda s: ZIO.succeed(len(s)) assert ZIO.access_m(accessor)._run("hello") == Right(5)
def test_environment_1() -> None: assert Environment[int]()._run(42) == Right(42) def test_environment_2() -> None: assert Environment[int]().provide(42)._run(()) == Right(42) def test_environment_3() -> None: assert Environment[int]().provide(42).provide("asdf")._run(()) == Right(42) @pytest.mark.parametrize( "program,environment,expected_result", [ (ZIO.succeed(42), None, Right(42)), (ZIO.fail(Bippy()), None, Left(Bippy)), (ZIO.effect(lambda: 42), None, Right(42)), (ZIO.effect(lambda: _raise(Bippy())), None, Left(Bippy)), # type: ignore (ZIO.effect_catch(lambda: 42, Bippy), None, Right(42)), (ZIO.effect_catch(lambda: _raise(Bippy()), Bippy), None, Left(Bippy)), # type: ignore (ZIO.effect_catch(lambda: _raise(Bippy()), NotBippy), None, Left(Bippy)), # type: ignore (ZIO.succeed(42).catch(Bippy), None, Right(42)), (ZIO.access(len), "hello", Right(5)), (ZIO.access_m(lambda s: ZIO.succeed(len(s))), "hello", Right(5)), # type: ignore (ZIO.access_m(lambda s: ZIO.fail(Bippy())), "hello", Left(Bippy)), # type: ignore
def effect_total(side_effect: Thunk[A]) -> "ZIO[object, NoReturn, A]": return ZIO(lambda _: Right(side_effect()))
def access(f: Callable[[R], A]) -> "ZIO[R, NoReturn, A]": return ZIO(lambda r: Right(f(r)))
def test_environment_1() -> None: assert Environment[int]()._run(42) == Right(42)
def or_else( self: "ZIO[R, EE, AA]", other: "ZIO[R, E2, A2]") -> "ZIO[R, Union[EE, E2], Union[AA, A2]]": return ZIO(lambda r: self._run(r).fold(lambda e: other._run(r), lambda a: Right(a)))
def test_environment_3() -> None: assert Environment[int]().provide(42).provide("asdf")._run(()) == Right(42)
def either(self) -> "ZIO[R, NoReturn, Either[E, A]]": return ZIO(lambda r: Right(self._run(r)))
def or_die(self: "ZIO[R, X, AA]") -> "ZIO[R, NoReturn, AA]": return ZIO(lambda r: self._run(r).fold(_raise, lambda a: Right(a)))
def test_zio_lshift_1() -> None: assert ( ZIO.succeed(100) << ZIO.succeed(1) << ZIO.succeed(2) << ZIO.succeed(3) ).flat_map(lambda x: ZIO.succeed(f"The result is: {x}"))._run( ()) == Right("The result is: 3")
def test_flatten_right() -> None: x: Either[str, Either[str, int]] = Either.right(Either.right(42)) assert x.flatten() == Right(42)
def test_zio_zip_1() -> None: assert ZIO.succeed("a").zip(ZIO.succeed(42))._run(()) == Right(("a", 42))
environment: R expected_output: Either[E, A] def is_satisfied(self) -> bool: output_p = unsafe_run(self.p.either().provide(self.environment)) output_q = unsafe_run(self.q.either().provide(self.environment)) return output_p == output_q == self.expected_output @monadic def _q1(do: ZIOMonad[object, NoReturn]) -> ZIO[object, NoReturn, int]: result = do << ZIO.succeed(42) return ZIO.succeed(result) EQ1: Final = Equiv(ZIO.succeed(42), _q1(), (), Right(42)) @monadic def _q2(do: ZIOMonad[object, NoReturn]) -> ZIO[object, NoReturn, int]: result = do << ZIO.succeed(42) return ZIO.succeed(result) EQ2: Final = Equiv(ZIO.succeed(42), _q2(), (), Right(42)) @monadic def _q3(do: ZIOMonad[object, Bippy]) -> ZIO[object, Bippy, int]: do << ZIO.fail(Bippy()) return ZIO.succeed(42)
def __init__(self) -> None: self._run = lambda r: Right(r)