def test_zio_lshift_2() -> None:
def _kaboom(x: object) -> Either[NoReturn, int]:
raise Bippy
assert ((ZIO.succeed(100) << ZIO.succeed(1) << ZIO.succeed(2) <<
ZIO(_kaboom) << ZIO.succeed(3)).flat_map(lambda x: ZIO.succeed(
f"The result is: {x}")).catch(Bippy))._run(
()) == Left(Bippy())
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_flatten_2() -> None:
count = 0
def _impure_function(x: int) -> ZIO[object, NoReturn, int]:
nonlocal count
count += 1
return ZIO.succeed(x + 1)
def _kaboom(x: int) -> ZIO[object, NoReturn, int]:
raise Bippy
assert (ZIO.succeed(100).flat_map(_impure_function).flat_map(
_kaboom).flat_map(_impure_function).flat_map(_impure_function).map(
lambda x: ZIO.succeed(f"The result is: {x}")).catch(
Bippy).flatten()._run(())) == Left(Bippy())
assert count == 1
def program(
do: ZIOMonad[Console, Union[EOFError, KeyboardInterrupt]]
) -> ZIO[Console, Union[EOFError, KeyboardInterrupt], str]:
con = do << Environment()
do << con.print("Hello, what is your name?")
name = do << con.input()
do << con.print(f"Your name is: {name}")
x = do << ZIO.succeed(1)
while x < 20:
x = do << (
ZIO.succeed(x).map(lambda p: p + 1).flat_map(lambda q: ZIO.succeed(
q - 1)).flat_map(lambda r: ZIO.succeed(r + 1)))
do << con.print(f"The value of x is: {x}")
return ZIO.succeed(f"Hello, {name}!")
def prog(
do: ZIOMonad[ConsoleSystemEnvironment, NoReturn]
) -> ZIO[ConsoleSystemEnvironment, NoReturn, int]:
age = do << console.get_input_from_console(
prompt="How old are you?\n",
parse_value=ZIO.from_callable(str).map(int).catch(
ValueError).either().to_callable(),
default_value=21)
do << console.print(f"You are {age} years old.")
return ZIO.succeed(age)
def get_input_from_console(
self, prompt: str, parse_value: Callable[[str], Either[E, A]],
default_value: Optional[A],
do: ZIOMonad[System, NoReturn]) -> ZIO[System, NoReturn, A]:
while True:
keyboard_input = do << (
self.input(prompt).either().map(lambda e: e.to_union()))
if isinstance(keyboard_input, (EOFError, KeyboardInterrupt)):
do << self.print("")
system = do << Environment()
return system.exit()
if keyboard_input == '' and default_value is not None:
return ZIO.succeed(default_value)
parse_result = parse_value(keyboard_input)
if isinstance(parse_result, Right):
return ZIO.succeed(parse_result.value)
def ask(self, prompt: str, default: Literal['y', 'n'],
do: ZIOMonad[System, NoReturn]) -> ZIO[System, NoReturn, bool]:
default_str = 'Y/n' if default == 'y' else 'y/N'
choice = do << self.get_input_from_console(
prompt=f"{prompt} [{default_str}]: ",
parse_value=(ZIO.from_callable(str).map(str.lower).require(
lambda s: s in {'y', 'n'},
lambda s: s).either().to_callable()),
default_value=default)
return ZIO.succeed(choice == 'y')
def input(
self,
prompt: Optional[str] = None
) -> ZIO[object, Union[EOFError, KeyboardInterrupt], str]:
user_input = self._user_input.pop(0)
self._effects.append(console_effect.Input(prompt, user_input))
if isinstance(user_input, str):
return ZIO.succeed(user_input)
else:
result: Union[EOFError, KeyboardInterrupt] = user_input
return ZIO.fail(result)
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_map_2() -> None:
count = 0
def _impure_function(x: int) -> int:
nonlocal count
count += 1
return x + 1
def _kaboom(x: int) -> int:
raise Bippy
assert (ZIO.succeed(100).map(_impure_function).map(_kaboom).map(
_impure_function).map(_impure_function).map(
lambda x: f"The result is: {x}").catch(Bippy)._run(
())) == Left(Bippy())
assert count == 1
def test_zio_succeed() -> None:
assert ZIO.succeed(42)._run(()) == Right(42)
def test_zio_or_die_1() -> None:
assert ZIO.succeed(42).or_die()._run(()) == Right(42)
def test_zio_either_1() -> None:
assert ZIO.succeed("a").either()._run(()) == Right(Right("a"))
def test_zio_zip_3() -> None:
assert ZIO.succeed("a").zip(ZIO.fail(42))._run(()) == Left(42)
def test_zio_zip_1() -> None:
assert ZIO.succeed("a").zip(ZIO.succeed(42))._run(()) == Right(("a", 42))
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 print(self, line: str) -> ZIO[object, NoReturn, None]:
self._effects.append(console_effect.Print(line))
return ZIO.succeed(None)
def _impure_function(x: int) -> ZIO[object, NoReturn, int]:
nonlocal count
count += 1
return ZIO.succeed(x + 1)
def _q5(do: ZIOMonad[object, Exception]) -> ZIO[object, Exception, int]:
do << ZIO.effect(lambda: _raise(Bippy())) # type: ignore
return ZIO.succeed(42)
def _q7(do: ZIOMonad[object, NotBippy]) -> ZIO[object, NotBippy, int]:
result: int = do << (
ZIO.effect_catch(lambda: _raise(Bippy()), NotBippy).catch(Bippy) # type: ignore
)
return ZIO.succeed(result)
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 _q3(do: ZIOMonad[object, Bippy]) -> ZIO[object, Bippy, int]:
do << ZIO.fail(Bippy())
return ZIO.succeed(42)
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 _q2(do: ZIOMonad[object, NoReturn]) -> ZIO[object, NoReturn, int]:
result = do << ZIO.succeed(42)
return ZIO.succeed(result)
def _q4(do: ZIOMonad[object, Exception]) -> ZIO[object, Exception, int]:
result = do << ZIO.effect(lambda: 42)
return ZIO.succeed(result)
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 _q6(do: ZIOMonad[object, Bippy]) -> ZIO[object, Bippy, int]:
result = do << ZIO.effect_catch(lambda: _raise(Bippy()), Bippy) # type: ignore
return ZIO.succeed(result)
