def profile(count=256):
"""Run a reduce(lib.gyte_test(lib.byte_table[n])) for the first count
bytes."""
examples = sorted(lib.byte_table.items())
for n, byte in examples[:count]:
engine.reduce(lib.byte_test(byte))
sys.stdout.write('.')
sys.stdout.flush()
def repl(fmt='sexpr'):
"""Read eval print loop."""
parse, print_, simplify = FORMATS[fmt]
while True:
sys.stdout.write('> ')
sys.stdout.flush()
try:
string = raw_input()
except KeyboardInterrupt:
sys.stderr.write('Bye!\n')
sys.stderr.flush()
return
try:
code = parse(string)
result = engine.reduce(code)
result_string = print_(result)
sys.stdout.write(result_string)
sys.stdout.write('\n')
sys.stdout.flush()
except Exception as e:
sys.stderr.write(str(e))
sys.stderr.write('\n')
sys.stderr.flush()
continue
def test_fix(value, expected):
assert reduce(value) == expected
def py_fun(*py_args):
assert len(py_args) == len(encode_args)
un_args = tuple(e(a) for (e, a) in zip(encode_args, py_args))
un_result = reduce(app(un_fun, *un_args))
py_result = decode_result(un_result)
return py_result
def test_enum_flatten(xs, expected):
assert reduce(lib.enum_flatten(xs)) == expected
def test_enum_filter(p, xs, expected):
assert reduce(lib.enum_filter(p, xs)) == expected
def test_enum_union(xs, ys, expected):
assert reduce(lib.enum_union(xs, ys)) == expected
def test_list_size(xs, expected):
assert reduce(lib.list_size(xs)) == expected
def test_bool_or(x, y, expected):
assert reduce(lib.bool_or(x, y)) == expected
def test_byte_test_ok(n, byte):
assert reduce(lib.byte_test(byte)) == ok
def test_byte_test(expected, bits):
byte = lib.byte_make(*bits)
assert reduce(lib.byte_test(byte)) == expected
def test_enum_contains(xs, y, expected):
qxs = quote(enum(xs))
qy = quote(y)
assert reduce(lib.enum_contains(qxs, qy)) == expected
def test_div_constructed(x, expected):
assert reduce(app(a_div, x)) == expected
def test_div(x, expected):
assert reduce(lib.div(x)) == expected
def test_close(f, x, expected):
assert reduce(app(lib.close(f), x)) == expected
def test_list_filter(p, xs, expected):
assert reduce(lib.list_filter(p, xs)) == expected
def test_list_sort(list_):
xs = num_list(list_)
expected = num_list(sorted(list_))
actual = reduce(lib.list_sort(lib.num_lt, xs))
assert actual == expected, lazy_actual_vs_expected(actual, expected)
def test_num_lt(x, y, expected):
assert reduce(lib.num_lt(x, y)) == expected
def test_list_quote(x, expected):
quote_item = lib.num_quote
assert reduce(lib.list_quote(quote_item, x)) == expected
def test_num_rec(z, s, x, expected):
assert reduce(lib.num_rec(z, s, x)) == expected
def test_enum_any(xs, expected):
assert reduce(lib.enum_any(xs)) == expected
def test_num_quote(x, expected):
assert reduce(lib.num_quote(x)) == expected
def test_enum_map(f, xs, expected):
assert reduce(lib.enum_map(f, xs)) == expected
def test_list_any(x, expected):
assert reduce(lib.list_any(x)) == expected
def test_enum_close(f, xs, expected):
assert reduce(lib.enum_close(f, xs)) == simplify(expected)
def test_list_cat(xs, ys, expected):
assert reduce(lib.list_cat(xs, ys)) == expected
def test_list_map(f, x, expected):
assert reduce(lib.list_map(f, x)) == expected
def test_list_rec(n, c, x, expected):
assert reduce(lib.list_rec(n, c, x)) == expected
def test_trace_reduce_equations(code, expected, message):
with xfail_if_not_implemented():
actual = engine.reduce(code, BUDGET)
assert actual == expected, message
def test_fun_type_fixes(value, type_):
assert reduce(app(type_, value)) == reduce(as_code(value))
