def test_applicative_law_interchange(appl):
# u <*> pure y = pure ($ y) <*> u
y = object()
u = tc.pure(appl, str)
left = tc.apply(tc.pure(appl, y), u)
right = tc.apply(u, tc.pure(appl, lambda a: a(y)))
assert left == right
def test_applicative_law_homomorphism(appl):
# pure f <*> pure x = pure (f x)
x = object()
f = id
left = tc.apply(tc.pure(appl, x), tc.pure(appl, f))
right = tc.pure(appl, f(x))
assert left == right
def test_applicative_law_interchange(datas):
# u <*> pure y = pure ($ y) <*> u
y, appl, funcs = datas
u = tc.pure(appl, funcs[0])
left = tc.apply(tc.pure(appl, y), u)
right = tc.apply(u, tc.pure(appl, lambda a: a(y)))
assert left == right
def test_applicative_law_homomorphism(datas):
# pure f <*> pure x = pure (f x)
x, appl, funcs = datas
f = funcs[0]
left = tc.apply(tc.pure(appl, x), tc.pure(appl, f))
right = tc.pure(appl, f(x))
assert left == right
def test_applicative_law_interchange(datas):
# u <*> pure y = pure ($ y) <*> u
y, appl, funcs = datas
u = tc.pure(appl, funcs[0])
left = tc.apply(tc.pure(appl, y), u)
right = tc.apply(u, tc.pure(appl, lambda a: a(y)))
assert left == right
def test_applicative_law_homomorphism(datas):
# pure f <*> pure x = pure (f x)
x, appl, funcs = datas
f = funcs[0]
left = tc.apply(tc.pure(appl, x), tc.pure(appl, f))
right = tc.pure(appl, f(x))
assert left == right
def test_applicative_law_composition(appl):
# pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
u = tc.pure(appl, lambda a: [a])
v = tc.pure(appl, str)
w = appl
def compose(f1):
return lambda f2: lambda a: f1(f2(a))
left = tc.apply(w, tc.apply(v, tc.apply(u, tc.pure(appl, compose))))
right = tc.apply(tc.apply(w, v), u)
assert left == right
def test_applicative_law_composition(datas):
# pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
_, appl, funcs = datas
u = tc.pure(appl, funcs[0])
v = tc.pure(appl, funcs[1])
w = appl
def compose(f1):
return lambda f2: lambda a: f1(f2(a))
left = tc.apply(w, tc.apply(v, tc.apply(u, tc.pure(appl, compose))))
right = tc.apply(tc.apply(w, v), u)
assert left == right
def test_applicative_law_composition(datas):
# pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
_, appl, funcs = datas
u = tc.pure(appl, funcs[0])
v = tc.pure(appl, funcs[1])
w = appl
def compose(f1):
return lambda f2: lambda a: f1(f2(a))
left = tc.apply(w, tc.apply(v, tc.apply(u, tc.pure(appl, compose))))
right = tc.apply(tc.apply(w, v), u)
assert left == right
def test_applicative_law_identity(data):
# pure id <*> v = v
def identity(a):
return a
assert tc.apply(data, tc.pure(data, identity)) == data
def test_applicative_law_identity(data):
# pure id <*> v = v
def identity(a):
return a
assert tc.apply(data, tc.pure(data, identity)) == data
