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 list_sort(lt, xs):
return let(
app(list_sort, lt), lambda sort:
app(xs, nil, lambda h, t:
let(app(lt, h), lambda lt_h:
app(list_cat,
app(sort, app(list_filter, lt_h, t)),
cons(h,
app(sort,
app(list_filter, compose(bool_not, lt_h), t)))))))
def a_construct():
return join_(
app(pair, I, I),
app(pair, BOT, TOP),
app(pair, div, BOT),
app(pair, a_copy, a_join),
app(pair, C, C),
app(a_preconj, a_construct),
app(a_postconj, a_construct),
app(a_compose, a_construct, a_construct),
)
def __call__(self, *args):
if len(args) != len(self._encoders):
raise TypeError('{} takes {} arguments ({} given)'.format(
self.__name__, len(self._encoders), len(args)))
if ENGINE is None:
raise RuntimeError('No engine specified')
code_args = [encode(arg) for encode, arg in izip(self._encoders, args)]
code_in = app(self.combinator.code, *code_args)
code_out = ENGINE.reduce(code_in)
io.check_for_errors(code_out)
data_out = self._decoder(code_out)
return data_out
def trace(*part_names, **kwargs):
"""Trace an approximation to A.
Possible names: all base copy div bot swap preconj postconj compose
Kwargs:
steps = 10
type = '(FUN r (FUN s (FUN f (FUN x (r (f (s x)))))))'
inhab = '(FUN x x)'
fmt = 'sexpr' (one of: 'sexpr', 'tiny')
"""
print_ = PRINTERS[kwargs.get('fmt', 'sexpr')]
# Construct an approximation of A with only a few parts.
if 'all' in part_names:
part_names = PARTS.keys()
for name in part_names:
print('{} = {}'.format(name, print_(simplify(PARTS[name]))))
assert name in PARTS, name
A = simplify(build_A(*part_names))
print('A = {}'.format(print_(A)))
# Cast a candidate inhabitant via the defined type.
type_ = sexpr_simplify(kwargs.get('type', default_type))
inhab = sexpr_simplify(kwargs.get('inhab', default_inhab))
term = simplify(app(A, type_, inhab))
print('0\t{}'.format(print_(term)))
# Print a reduction sequence.
steps = int(kwargs.get('steps', 10))
for step in xrange(steps):
term = try_compute_step(term)
if term is None:
print '--- Normalized ---'
return
print('{}\t{}'.format(1 + step, print_(term)))
print('... Not normalized ...')
def div_rec_call(x):
return join_(x, div_rec_call(app(x, TOP)))
from pomagma.reducer.code import I, K, B, C, S, TOP, NVAR, APP
from pomagma.reducer.sugar import _compile
from pomagma.reducer.sugar import combinator, as_code, app, join_
from pomagma.util.testing import for_each
import pytest
f = NVAR("f")
x = NVAR("x")
y = NVAR("y")
z = NVAR("z")
CODE_EXAMPLES = [(I, I), (K, K), (app(S, I, I), app(S, I, I))]
CLOSED_FUN_EXAMPLES = [
(lambda: x, x),
(lambda: B, B),
(lambda x: x, I),
(lambda x, y: x, K),
(lambda x, y: y, APP(K, I)),
(lambda x: lambda y: x, K),
(lambda x: lambda x: x, APP(K, I)),
(lambda x, y, z: app(x, z, y), C),
(lambda x, y, z: app(x, app(y, z)), B),
(lambda x, y, z: app(x, z, app(y, z)), S),
(lambda x: app(x, x), app(S, I, I)),
(lambda x: app(f, app(x, x)), app(B, f, app(S, I, I))),
]
OPEN_FUN_EXAMPLES = [(lambda: x, x), (lambda x: y, app(K, y)), (lambda x: app(f, x), f)]
from pomagma.reducer import lib
from pomagma.reducer.code import NVAR
from pomagma.reducer.linker import link
from pomagma.reducer.sugar import as_code, app
from pomagma.util.testing import for_each
x = NVAR('x')
@for_each([
(NVAR('lib.true'), lib.true),
(NVAR('lib.false'), lib.false),
(NVAR('lib.zero'), lib.zero),
(NVAR('lib.succ'), lib.succ),
(app(x, NVAR('lib.ok'), NVAR('lib.ok')), app(x, lib.ok, lib.ok)),
])
def test_link(code, expected):
expected = as_code(expected)
actual = link(code)
assert actual == expected
def bool_and(x, y):
return app(x, y, false)
def bool_test(x):
return app(x, ok, ok)
def unit_quote(x):
x = unit_type(x)
return app(x, QUOTE(ok))
def unit_and(x, y):
return app(x, y)
def a_join(f, x, y):
return app(f, join_(x, y))
def a_copy(f, x):
return app(f, x, x)
def div(f):
return join_(f, app(div, f, TOP))
def byte_make(b0, b1, b2, b3, b4, b5, b6, b7):
result = I
for b in (b0, b1, b2, b3, b4, b5, b6, b7):
result = app(C, result, b)
return result
def bytes_test(xs):
return unit_type(
app(xs, ok, lambda h, t: unit_and(byte_test(h), bytes_test(t))))
def construct(f):
"""The simple type constructor, aka AAA."""
return app(a_construct, f)
def bool_type(x):
return app(BOOL, x)
def a_arrow(a, b):
return lambda f, x: app(b, app(f, app(a, x)))
def bool_not(x):
return app(x, false, true)
def equal(x, y):
return bool_type(app(EQUAL, x, y))
def partial_pred(x):
return app(x, lib.undefined, lambda px: px)
def less(x, y):
return bool_type(app(LESS, x, y))
def un_all_different(xs):
return app(xs, lib.true, lambda h, t:
lib.bool_and(
lib.list_all(lambda x: lib.bool_not(lib.list_num_eq(h, x))),
all_different(t)))
def enum_contains(qxs, qy):
return app(LESS, qapp(quote(box), qy), qxs)
def Y(f):
return app(lambda x: app(f, app(x, x)), lambda x: app(f, app(x, x)))
def _bits_test(b0, b1, b2, b3, b4, b5, b6, b7):
bits = [b0, b1, b2, b3, b4, b5, b6, b7]
tests = map(bool_test, bits)
return app(join_(*tests), *tests)
def div_rec_app(x):
return join_(x, app(div_rec_app, app(x, TOP)))
def byte_test(x):
return unit_type(app(x, _bits_test))
