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)