def test_apply_apply_second(cls, data): # Draw types a = data.draw(testing.sample_type()) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_apply_type_constructor()) fa = f(a) fb = f(b) # Draw values u = data.draw(fa) v = data.draw(fb) cls.assert_apply_apply_second(u, v, data=data) return
def check(app_trans, app1, app2): a = data.draw(testing.sample_hashable_type()) b = data.draw(testing.sample_type()) t = data.draw(cls.sample_traversable_type_constructor()) f = data.draw(app1.sample_applicative_type_constructor()) x = data.draw(t(a)) g = data.draw(testing.sample_function(f(b))) cls.assert_traversable_traverse_naturality( x, g, app_trans, app1, app2, data=data, ) cls.assert_traversable_sequence_naturality( x.map(g), app_trans, app1, app2, data=data, ) return
class Identity(Monad, Eq): x = attr.ib() @class_function def pure(cls, x): return cls(x) def bind(self, f): """Identity a -> (a -> Identity b) -> Identity b""" return f(self.x) def __eq__(self, other): """Identity a -> Identity a -> bool""" return self.x == other.x def __repr__(self): return "Identity({})".format(repr(self.x)) def __eq_test__(self, other, data): return eq_test(self.x, other.x, data) @class_function def sample_value(cls, a): return a.map(Identity) sample_type = testing.create_type_sampler(testing.sample_type(), ) sample_functor_type_constructor = testing.create_type_constructor_sampler() # Some typeclass instances have constraints for the types inside sample_eq_type = testing.create_type_sampler(testing.sample_eq_type(), )
def test_traversable_composition(cls, data): """Test composition law of traverse""" # Sample an applicative type constructor from haskpy.typeclasses.applicative import Applicative app_f = data.draw(testing.sample_class(Applicative)) app_g = data.draw(testing.sample_class(Applicative)) # Sample types a = data.draw(testing.sample_hashable_type()) b = data.draw(testing.sample_hashable_type()) c = data.draw(testing.sample_type()) t = data.draw(cls.sample_traversable_type_constructor()) m_f = data.draw(app_f.sample_applicative_type_constructor()) m_g = data.draw(app_g.sample_applicative_type_constructor()) # Sample values x = data.draw(t(a)) f = data.draw(testing.sample_function(m_f(b))) g = data.draw(testing.sample_function(m_g(c))) # Check the law from haskpy import map cls.assert_traversable_traverse_composition(x, f, g, app_f, app_g, data=data) cls.assert_traversable_sequence_composition(map(map(g), x.map(f)), app_f, app_g, data=data) return
def test_monad_right_identity(cls, data): # Draw types a = data.draw(testing.sample_type()) m = data.draw(cls.sample_monad_type_constructor()) ma = m(a) # Draw values m = data.draw(ma) cls.assert_monad_right_identity(m, data=data) return
def test_applicative_homomorphism(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) # Draw values x = data.draw(a) f = data.draw(testing.sample_function(b)) cls.assert_applicative_homomorphism(f, x, data=data) return
def test_applicative_identity(cls, data): # Draw types a = data.draw(testing.sample_type()) f = data.draw(cls.sample_applicative_type_constructor()) fa = f(a) # Draw values v = data.draw(fa) cls.assert_applicative_identity(v, data=data) return
def test_contravariant_identity(cls, data): # Draw types a = data.draw(testing.sample_type()) t = data.draw(cls.sample_contravariant_type_constructor()) ta = t(a) # Draw values v = data.draw(ta) cls.assert_contravariant_identity(v, data=data) return
def test_profunctor_identity(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_profunctor_type_constructor()) fab = f(a, b) # Draw values x = data.draw(fab) cls.assert_profunctor_identity(x, data=data) return
def test_functor_replace(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_functor_type_constructor()) fa = f(a) # Draw values v = data.draw(fa) x = data.draw(b) cls.assert_functor_replace(v, x, data=data) return
def test_functor_map(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_functor_type_constructor()) fa = f(a) # Draw values v = data.draw(fa) f = data.draw(testing.sample_function(b)) cls.assert_functor_map(v, f, data=data) return
def test_profunctor_contramap(cls, data): # Draw types b = data.draw(testing.sample_eq_type()) d = data.draw(testing.sample_type()) f = data.draw(cls.sample_profunctor_type_constructor()) fbd = f(b, d) # Draw values x = data.draw(fbd) f = data.draw(testing.sample_function(b)) cls.assert_profunctor_contramap(x, f, data=data) return
def test_contravariant_contrareplace(cls, data): # Draw types a = data.draw(testing.sample_type()) b = data.draw(testing.sample_eq_type()) t = data.draw(cls.sample_contravariant_type_constructor()) ta = t(a) # Draw values v = data.draw(ta) x = data.draw(b) cls.assert_contravariant_contrareplace(v, x, data=data) return
def test_monad_left_identity(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) m = data.draw(cls.sample_monad_type_constructor()) mb = m(b) # Draw values f = data.draw(testing.sample_function(mb)) x = data.draw(a) cls.assert_monad_left_identity(f, x, data=data) return
def test_monad_map(cls, data): """Test consistency of ``map`` with the default implementation""" # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) m = data.draw(cls.sample_monad_type_constructor()) ma = m(a) u = data.draw(ma) f = data.draw(testing.sample_function(b)) cls.assert_monad_map(u, f, data=data) return
def test_contravariant_contramap(cls, data): # Draw types a = data.draw(testing.sample_type()) b = data.draw(testing.sample_eq_type()) t = data.draw(cls.sample_contravariant_type_constructor()) ta = t(a) # Draw values v = data.draw(ta) f = data.draw(testing.sample_function(b)) cls.assert_contravariant_contramap(v, f, data=data) return
def test_applicative_interchange(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_applicative_type_constructor()) fab = f(testing.sample_function(b)) # Draw values y = data.draw(a) u = data.draw(fab) cls.assert_applicative_interchange(u, y, data=data) return
def test_bind_join(cls, data): """Test consistency of ``join`` with the default implementation""" # Draw types b = data.draw(testing.sample_type()) m = data.draw(cls.sample_bind_type_constructor()) mb = m(b) mmb = m(mb) # Draw values u = data.draw(mmb) cls.assert_bind_join(u, data=data) return
def test_foldable_null(cls, data): # Draw types a = data.draw(testing.sample_type()) f = data.draw(cls.sample_foldable_type_constructor()) fa = f(a) # Draw values xs = data.draw(fa) with catch_warnings(): filterwarnings("ignore", category=PerformanceWarning) cls.assert_foldable_null(xs, data=data) return
def test_apply_apply(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_apply_type_constructor()) fa = f(a) fab = f(testing.sample_function(b)) # Draw values v = data.draw(fa) u = data.draw(fab) cls.assert_apply_apply(u, v, data=data) return
def test_profunctor_map(cls, data): # Draw types b = data.draw(testing.sample_eq_type()) c = data.draw(testing.sample_eq_type()) d = data.draw(testing.sample_type()) f = data.draw(cls.sample_profunctor_type_constructor()) fbc = f(b, c) # Draw values x = data.draw(fbc) g = data.draw(testing.sample_function(d)) cls.assert_profunctor_map(x, g, data=data) return
def test_applicative_map(cls, data): """Test consistency between Applicative and Functor implementations""" # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_applicative_type_constructor()) fa = f(a) # Draw values v = data.draw(fa) f = data.draw(testing.sample_function(b)) cls.assert_applicative_map(v, f, data=data) return
def test_traversable_identity(cls, data): """Test identity law of traverse""" # Sample types a = data.draw(testing.sample_type()) t = data.draw(cls.sample_traversable_type_constructor()) # Sample values x = data.draw(t(a)) # Check the laws cls.assert_traversable_traverse_identity(x, data=data) cls.assert_traversable_sequence_identity(x, data=data) return
def test_bind_bind(cls, data): """Test consistency of ``bind`` with the default implementation""" # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) m = data.draw(cls.sample_bind_type_constructor()) ma = m(a) mb = m(b) # Draw values u = data.draw(ma) f = data.draw(testing.sample_function(mb)) cls.assert_bind_bind(u, f, data=data) return
def test_bind_associativity(cls, data): a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_eq_type()) c = data.draw(testing.sample_type()) m = data.draw(cls.sample_bind_type_constructor()) ma = m(a) mb = m(b) mc = m(c) m = data.draw(ma) f = data.draw(testing.sample_function(mb)) g = data.draw(testing.sample_function(mc)) cls.assert_bind_associativity(m, f, g, data=data) return
def test_functor_composition(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_eq_type()) c = data.draw(testing.sample_type()) f = data.draw(cls.sample_functor_type_constructor()) fa = f(a) # Draw values v = data.draw(fa) g = data.draw(testing.sample_function(b)) h = data.draw(testing.sample_function(c)) cls.assert_functor_composition(v, g, h, data=data) return
def test_bind_apply(cls, data): """Test consistency ``apply`` with the default implementations""" # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) m = data.draw(cls.sample_bind_type_constructor()) ma = m(a) mab = m(testing.sample_function(b)) # Draw values v = data.draw(ma) u = data.draw(mab) cls.assert_bind_apply(u, v, data=data) return
def test_cartesian_identity(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_cartesian_type_constructor()) fab = f(a, b) # Draw values h = data.draw(fab) cls.assert_cartesian_identity( h, data=data, input_strategy=st.tuples(st.integers(), st.just(())), ) return
def test_cartesian_associativity(cls, data): # Draw types a = st.tuples(data.draw(testing.sample_eq_type()), st.tuples( st.just("foo"), st.just("bar"), )) b = data.draw(testing.sample_type()) f = data.draw(cls.sample_cartesian_type_constructor()) fab = f(a, b) # Draw values h = data.draw(fab) cls.assert_cartesian_associativity(h, data=data, input_strategy=a) return
def test_applicative_composition(cls, data): # Draw types a = data.draw(testing.sample_eq_type()) b = data.draw(testing.sample_eq_type()) c = data.draw(testing.sample_type()) f = data.draw(cls.sample_applicative_type_constructor()) fa = f(a) fab = f(testing.sample_function(b)) fbc = f(testing.sample_function(c)) # Draw values w = data.draw(fa) v = data.draw(fab) u = data.draw(fbc) cls.assert_applicative_composition(u, v, w, data=data) return