def sample(code, budget=0):
"""Beta-eta sample code, ignoring budget."""
assert isinstance(budget, int) and budget >= 0, budget
LOG.info('sample({})'.format(pretty(code)))
head = code
context = EMPTY_CONTEXT
for continuation in _sample_nonlinear(head, context):
yield _close(continuation, nonlinear=True)
def _compile(fun, actual_fun=None):
if actual_fun is None:
actual_fun = fun
args, vargs, kwargs, defaults = inspect.getargspec(actual_fun)
if vargs or kwargs or defaults:
source = inspect.getsource(actual_fun)
raise SyntaxError('Unsupported signature: {}'.format(source))
symbolic_args = map(NVAR, args)
symbolic_result = fun(*symbolic_args)
LOG.debug('compiling {}{} = {}'.format(
fun, tuple(symbolic_args), symbolic_result))
code = as_code(symbolic_result)
for var in reversed(symbolic_args):
code = abstract(var, code)
return code
def _compile(fun, actual_fun=None):
"""Convert lambdas to terms using Higher Order Abstract Syntax [1].
[1] Pfenning, Elliot (1988) "Higher-order abstract syntax"
https://www.cs.cmu.edu/~fp/papers/pldi88.pdf
"""
if actual_fun is None:
actual_fun = fun
args, vargs, kwargs, defaults = inspect.getargspec(actual_fun)
if vargs or kwargs or defaults:
source = inspect.getsource(actual_fun)
raise SyntaxError('Unsupported signature: {}'.format(source))
symbolic_args = map(NVAR, args)
symbolic_result = fun(*symbolic_args)
LOG.debug('compiling {}{} = {}'.format(
fun, tuple(symbolic_args), symbolic_result))
term = as_term(symbolic_result)
for var in reversed(symbolic_args):
term = convert.FUN(var, term)
return term
def simplify(code):
"""Linearly beta-eta reduce."""
LOG.info('simplify({})'.format(pretty(code)))
return _reduce(code, False)
def reduce(code, budget=0):
"""Beta-eta reduce code, ignoring budget."""
assert isinstance(budget, int) and budget >= 0, budget
LOG.info('reduce({})'.format(pretty(code)))
return _reduce(code, True)
