def test_either_eq_operator_should_compare_values(integer):
assert Right(integer) == Right(integer)
assert Right(integer) != Right(integer + 1)
assert Left(integer) == Left(integer)
assert Left(integer) != Left(integer + 1)
assert Right(integer) != Left(integer)
def test_either_monad_law(integer):
MonadLawTester(
monad=Right,
value=integer,
mapper1=lambda value: Right(value + 1),
mapper2=lambda value: Right(value + 2),
).test()
MonadLawTester(
monad=Left,
value=integer,
mapper1=lambda value: Left(value + 1),
mapper2=lambda value: Left(value + 2),
).test(run_left_law_test=False)
def to_either(self, *args):
"""
Transform Lazy into Either (Right) with constructor_fn result.
:returns: Right monad with constructor_fn result
:rtype: Right[A]
"""
from pymonet.either import Right
return Right(self.get(*args))
def to_either(self):
"""
Transform Box into Right either.
:returns: right Either monad with previous value
:rtype: Right[A]
"""
from pymonet.either import Right
return Right(self.value)
def test_either_functor_law(integer):
FunctorLawTester(
functor=Right(integer),
mapper1=lambda value: value + 1,
mapper2=lambda value: value + 2,
).test()
FunctorLawTester(
functor=Left(integer),
mapper1=lambda value: value + 1,
mapper2=lambda value: value + 2,
).test()
def to_either(self):
"""
Transform Maybe to Either.
:returns: Right monad with previous value when Maybe is not empty, in other case Left with None
:rtype: Either[A | None]
"""
from pymonet.either import Left, Right
if self.is_nothing:
return Left(None)
return Right(self.value)
def test_bind_should_be_applied_only_on_current_value_and_return_value():
assert Left(42).bind(lambda value: Right(value + 1)).value == 42
assert Right(42).bind(lambda value: Right(value + 1)).value == 43
assert Right(42).bind(lambda value: Left(value + 1)).value == 43
def test_is_left_should_return_suitable_value(integer):
assert Left(integer).is_left()
assert not Right(integer).is_left()
def test_mapper_should_be_applied_only_on_current_value(integer):
assert Left(integer).map(increase) == Left(integer)
assert Right(integer).map(increase) == Right(increase(integer))
def test_either_ap_on_left_should_not_be_applied(integer):
def lambda_fn():
raise TypeError
assert Left(integer).ap(Right(lambda_fn)) == Left(integer)
assert Left(integer).ap(Left(lambda_fn)) == Left(integer)
def to_either_test(self):
if self.is_fail:
assert self.monad(self.value).to_either() == Left(self.value)
else:
assert self.monad(self.value).to_either() == Right(self.value)