def encode(value):
if value is None:
return lib.none
if isinstance(value, tuple) and len(value) == 1:
return lib.some(encode_item(value[0]))
else:
raise TypeError(value)
def decode_maybe(decode_item):
item_var = unification.var('item')
some_pattern = lib.some(item_var)
def decode(code):
if code is lib.none:
return None
match = unification.unify(some_pattern, code)
if not match:
raise TypeError(code)
return (decode_item(match[item_var]),)
return decode
def decode_maybe(decode_item):
"""Decode to either None or (decode_item(...),)."""
item_var = NVAR('item')
some_pattern = lib.some(item_var)
def decode(term):
if term is lib.none:
return None
match = pattern.match(some_pattern, term)
if match is None:
raise TypeError(pretty(term))
return (decode_item(match[item_var]),)
return decode
],
'encode_error': [None, (), (True,), [True, 0], True, 0, 'asdf']
},
('sum', 'bool', 'num'): {
'ok': [
(lib.inl(lib.true), (True, True)),
(lib.inl(lib.false), (True, False)),
(lib.inr(lib.zero), (False, 0)),
(lib.inr(lib.succ(lib.succ(lib.zero))), (False, 2)),
],
'encode_error': [None, (), (True,), [True, 0], True, 0, 'asdf']
},
('maybe', 'bool'): {
'ok': [
(lib.none, None),
(lib.some(lib.true), (True,)),
(lib.some(lib.false), (False,)),
],
'encode_error': [True, False, 0, 1, 2, (), 'asdf'],
'decode_error': [I],
},
('list', 'bool'): {
'ok': [
(lib.nil, []),
(lib.cons(lib.true, lib.cons(lib.false, lib.nil)), [True, False]),
],
'encode_error': [None, True, False, 0, 1, 2, (), 'asdf', [[True]]],
'decode_error': [I],
},
('list', ('list', 'num')): {
'ok': [
@for_each([(true, true), (false, true), (join, false), (undefined, true), (error, false), (ok, false)])
def test_enum_bool(y, expected):
qxs = quote(lib.enum_bool)
assert simplify(lib.enum_contains(qxs, quote(y))) == expected
# ----------------------------------------------------------------------------
# Maybe
@for_each(
[
(lib.none, lib.none),
(lib.some(undefined), lib.some(undefined)),
(lib.some(error), lib.some(error)),
(lib.some(ok), lib.some(ok)),
(lib.some(true), lib.some(true)),
(lib.some(false), lib.some(false)),
(error, error),
(undefined, undefined),
(ok, error),
(join, error),
(join_(lib.none, lib.some(undefined)), error),
(join_(lib.some(true), lib.some(false)), lib.some(join)),
]
)
def test_maybe_type(x, expected):
assert simplify(lib.maybe_type(x)) == expected
(join, false),
(undefined, true),
(error, false),
(ok, false),
])
def test_enum_bool(y, expected):
qxs = quote(lib.enum_bool)
assert simplify(lib.enum_contains(qxs, quote(y))) == expected
# ----------------------------------------------------------------------------
# Maybe
@for_each([
(lib.none, lib.none),
(lib.some(undefined), lib.some(undefined)),
(lib.some(error), lib.some(error)),
(lib.some(ok), lib.some(ok)),
(lib.some(true), lib.some(true)),
(lib.some(false), lib.some(false)),
(error, error),
(undefined, undefined),
(ok, error),
(join, error),
(join_(lib.none, lib.some(undefined)), error),
(join_(lib.some(true), lib.some(false)), lib.some(join)),
])
def test_maybe_type(x, expected):
assert simplify(lib.maybe_type(x)) == expected
