def maybe_quote(quote_some, x):
x = maybe_type(x)
return app(
x,
QUOTE(none),
lambda y: qapp(quote(some), app(quote_some, y)),
)
def prod_quote(quote_fst, quote_snd, xy):
return app(
xy,
lambda x, y: qapp(quote(pair), app(quote_fst, x), app(quote_snd, y)),
)
def qfix(qf):
return EVAL(qf, qapp(quote(qfix), qf))
def enum_contains(qxs, qy):
return QLESS(qapp(quote(box), qy), qxs)
[
(ok, ok, ok),
(ok, undefined, ok),
(undefined, ok, ok),
(undefined, undefined, undefined),
(ok, true, error),
(ok, false, error),
(true, ok, error),
(false, ok, error),
]
)
def test_unit_or(x, y, expected):
assert simplify(lib.unit_or(x, y)) == expected
@for_each([(ok, quote(ok)), (undefined, undefined), (error, error), (true, error), (false, error)])
def test_unit_quote(x, expected):
assert simplify(lib.unit_quote(x)) == expected
@for_each([(ok, true), (undefined, true), (error, false), (true, false), (false, false)])
def test_enum_unit(y, expected):
qxs = quote(lib.enum_unit)
assert simplify(lib.enum_contains(qxs, quote(y))) == expected
# ----------------------------------------------------------------------------
# Bool
@for_each([(true, true), (false, false), (error, error), (undefined, undefined), (ok, error), (join, error)])
def list_quote(quote_item, xs):
return xs(QUOTE(nil), lambda h, t:
qapp(quote(cons), quote_item(h), list_quote(t)))
def maybe_quote(quote_some, x):
x = maybe_type(x)
return x(QUOTE(none), lambda y: qapp(quote(some), quote_some(y)))
def list_quote(quote_item, xs):
return app(
xs,
QUOTE(nil),
lambda h, t: qapp(quote(cons), app(quote_item, h), list_quote(t)),
)
def test_enum_num(y, expected):
qxs = quote(lib.enum_num)
assert simplify(lib.enum_contains(qxs, quote(y))) == expected
def test_enum_list(enum_item, y, expected):
qxs = quote(lib.enum_list(enum_item))
assert simplify(lib.enum_contains(qxs, quote(y))) == expected
def test_enum_sum(enum_inl, enum_inr, y, expected):
qxs = quote(lib.enum_sum(enum_inl, enum_inr))
assert simplify(lib.enum_contains(qxs, quote(y))) == expected
def test_enum_prod(enum_fst, enum_snd, y, expected):
qxs = quote(lib.enum_prod(enum_fst, enum_snd))
assert simplify(lib.enum_contains(qxs, quote(y))) == expected
def test_enum_contains(xs, y, expected):
qxs = quote(enum(xs))
qy = quote(y)
assert reduce(lib.enum_contains(qxs, qy)) == expected
def sum_quote(quote_inl, quote_inr, xy):
return app(
xy,
lambda x: qapp(quote(inl), app(quote_inl, x)),
lambda y: qapp(quote(inr), app(quote_inr, y)),
)
def prod_quote(quote_fst, quote_snd, xy):
return xy(lambda x, y: qapp(quote(pair), quote_fst(x), quote_snd(y)))
def num_quote(x):
return app(x, QUOTE(zero), lambda px: qapp(quote(succ), num_quote(px)))
def sum_quote(quote_inl, quote_inr, xy):
return xy(lambda x: qapp(quote(inl), quote_inl(x)),
lambda y: qapp(quote(inr), quote_inr(y)))
def enum_contains(qxs, qy):
return app(LESS, qapp(quote(box), qy), qxs)
def test_stream_quote(quote_item, xs):
assert lib.stream_quote(quote_item, xs) is quote(xs)
