def append(vals):
lists = kt.pythonify_list(vals)
if not lists:
return kt.nil
ret = lists.pop()
for ls in reversed(lists):
for el in reversed(kt.pythonify_list(ls)):
ret = kt.Pair(el, ret)
return ret
def transpose(pyklists):
"""
Convert a python list of kernel lists of the form:
[(a11 ... a1n),
(... ... ...),
(am1 ... amn)]
to a python list of kernel lists of the form:
[(a11 ... am1),
(... ... ...),
(a1n ... amn)]
"""
try:
pypylists = [kt.pythonify_list(l) for l in pyklists]
except kt.NonNullListTail as e:
kt.signal_value_error("Non-list passed to map", e.val)
else:
ln = len(pypylists[0])
for ls in pypylists[1:]:
if len(ls) != ln:
kt.signal_value_error("Different-sized lists passed to map",
kt.kernelify_list(pyklists))
t = [[l[i] for l in pypylists]
for i in range(ln)]
return [kt.kernelify_list([l[i] for l in pypylists])
for i in range(ln)]
def binds(vals, env, cont):
pyvals = kt.pythonify_list(vals)
if len(pyvals) < 1:
kt.signal_arity_mismatch(">=1", vals)
for symbol in pyvals[1:]:
kt.check_type(symbol, kt.Symbol)
env_expr = pyvals[0]
return env_expr, env, kt.BindsCont(pyvals, cont)
def apply_(vals, env_ignore, cont):
ls = kt.pythonify_list(vals)
if len(ls) == 2:
applicative, args = ls
env = kt.Environment([])
else:
applicative, args, env = ls
kt.check_type(applicative, kt.Applicative)
return kt.Pair(applicative.wrapped_combiner, args), env, cont
def sub(vals):
ls = kt.pythonify_list(vals)
if len(ls) < 2:
kt.signal_arity_mismatch('>=2', vals)
accum = ls[0]
for v in ls[1:]:
kt.check_type(v, kt.Number)
assert isinstance(v, kt.Number)
accum = accum.sub(v)
return accum
def extend_continuation(vals, env, cont):
args = kt.pythonify_list(vals)
if len(args) == 2:
cont_to_extend, receiver = args
recv_env = kt.Environment([])
else:
cont_to_extend, receiver, recv_env = args
kt.check_type(cont_to_extend, kt.Continuation)
kt.check_type(receiver, kt.Applicative)
kt.check_type(recv_env, kt.Environment)
return kt.ExtendCont(receiver, recv_env, cont_to_extend), env, cont
def lteq(vals):
ls = kt.pythonify_list(vals)
if len(ls) < 2:
return kt.true
latest = ls[0]
for v in ls[1:]:
kt.check_type(v, kt.Number)
assert isinstance(v, kt.Number)
if not latest.equal(v):
return kt.false
latest = v
return kt.true
def map_(vals, env, cont):
try:
args = kt.pythonify_list(vals)
except kt.NonNullListTail:
kt.signal_value_error("Argument tree to map is not a list", vals)
else:
if len(args) < 2:
kt.signal_arity_mismatch(">=2", vals)
app = args[0]
kt.check_type(app, kt.Applicative)
assert isinstance(app, kt.Applicative)
lists = args[1:]
return kt.map_(app.wrapped_combiner,
transpose(lists),
0,
env,
cont)
def check_guards(guards):
for guard in kt.iter_list(guards):
selector, interceptor = kt.pythonify_list(guard)
kt.check_type(selector, kt.Continuation)
kt.check_type(interceptor, kt.Applicative)
kt.check_type(interceptor.wrapped_combiner, kt.Operative)
def make_environment(vals):
return kt.Environment(kt.pythonify_list(vals))
