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_foldable_fold(cls, data):
# Draw types
from haskpy.typeclasses import Monoid
monoid = data.draw(testing.sample_class(Monoid))
a = data.draw(monoid.sample_monoid_type())
f = data.draw(cls.sample_foldable_type_constructor())
fa = f(a)
# Draw values
xs = data.draw(fa)
cls.assert_foldable_fold(xs, monoid, data=data)
return
def test_foldable_functor(cls, data):
from .functor import Functor
import pytest
if not issubclass(cls, Functor):
pytest.skip("{0} not Functor".format(cls.__name__))
# Draw types
from haskpy.typeclasses import Monoid
monoid = data.draw(testing.sample_class(Monoid))
b = data.draw(monoid.sample_monoid_type())
a = data.draw(testing.sample_eq_type())
f = data.draw(cls.sample_foldable_functor_type_constructor())
fa = f(a)
# Draw values
f = data.draw(testing.sample_function(b))
xs = data.draw(fa)
cls.assert_foldable_functor(xs, monoid, f, data=data)
return
def test_traversable_sequence(cls, data):
"""Test sequence based on the default implementation
The default implementation defines the law with respect to traverse.
"""
# Sample an applicative type constructor
from haskpy.typeclasses.applicative import Applicative
app = data.draw(testing.sample_class(Applicative))
# Sample types
a = data.draw(testing.sample_hashable_type())
t = data.draw(cls.sample_traversable_type_constructor())
f = data.draw(app.sample_applicative_type_constructor())
# Sample values
x = data.draw(t(f(a)))
# Check the law
cls.assert_traversable_sequence(app, x, data=data)
return