def make_map():
"""
in scheme
(define (map proc lis)
(cond ((null? lis)
'())
((pair? lis)
(cons (proc (car lis))
(map proc (cdr lis))))))
nil ≔ (nil)
map ≔ λ:
F, (cons X, Y) ↦ (cons μ(F, X), μ(map, F, Y))
_, nil ↦ nil
"""
f = Variable("F")
x = Variable("X")
y = Variable("Y")
_ = Variable("_")
_2 = Variable("_")
m = lamb()
m._name = "map"
m._rules = rules([([p(f), p(cons("cons", x, y))],
e(cons("cons", mu(f, [x]), mu(m, [f, y])))),
([p(_), p(nil())], e(nil()))])
return m
def test_lambda_not(self):
w_true = cons("true")
w_false = cons("false")
l = lamb(([w_true], w_false), ([w_false], w_true))
assert l.call([w_true]) == w_false
assert l.call([w_false]) == w_true
def test_simple_nested_constructor(self):
w_res = cons("zork", cons("barf"))
assert isinstance(w_res, W_Constructor)
assert w_res.get_tag() is tag("zork", 1)
assert w_res.get_number_of_children() is 1
w_subcons = w_res.get_child(0)
assert isinstance(w_subcons, W_Constructor)
assert w_subcons.get_tag() is tag("barf", 0)
assert w_subcons.get_number_of_children() is 0
def test_constructor_with_var(self):
var = Variable("x")
pat = pattern(cons("zork", var))
w_int = integer(1)
w_obj = cons("zork", w_int)
binding = [None]
var.binding_index = 0
pat.match(w_obj, binding)
assert binding[var.binding_index] == w_int
def make_append():
x1 = Variable("x")
x2 = Variable("x")
h = Variable("head")
t = Variable("tail")
l = lamb()
l._name = "append"
l._rules = rules([([p(nil()), p(x1)], e(x1)),
([p(cons("cons", h, t)),
p(x2)], e(cons("cons", h, mu(l, [t, x2]))))])
return l
def test_simple_constructor(self):
w_cons = cons("barf")
pat = pattern(w_cons)
w_obj = cons("barf")
binding = []
pat.match(w_obj, binding)
assert binding == []
w_obj = cons("zork")
with py.test.raises(NoMatch) as e:
pat.match(w_obj, binding)
def test_constructor_with_int(self):
w_cons = cons("zork", integer(1))
pat = pattern(w_cons)
w_obj = cons("zork", integer(1))
binding = []
pat.match(w_obj, binding)
assert binding == []
w_obj = cons("zork", integer(2))
with py.test.raises(NoMatch) as e:
pat.match(w_obj, binding)
def test_lambda_not(self):
w_true = cons("true")
w_false = cons("false")
l = lamb(([w_true], w_false), ([w_false], w_true))
res = interpret_expression(mu(l, [w_true]))
assert res == w_false
res = interpret_expression(mu(l, [w_false]))
assert res == w_true
def test_shuffle(self):
for i in range(20):
vars = [Variable("x%s" % n) for n in range(i)]
l = lamb(([cons("cons",
*vars)], cons("cons", *(vars[1:] + vars[:1]))))
l._name = "shuffle%s" % i
list1 = [integer(n) for n in range(i)]
w_cons1 = cons("cons", *list1)
res = l.call([w_cons1])
assert res == cons("cons", *(list1[1:] + list1[:1]))
def test_append(self):
x1 = Variable("x")
x2 = Variable("x")
h = Variable("head")
t = Variable("tail")
l = lamb()
l._rules = ziprules(
([nil(), x1], x1),
([cons("cons", h, t), x2], cons("cons", h, mu(l, [t, x2]))))
list1_w = [integer(1), integer(2), integer(3)]
list2_w = [integer(4), integer(5), integer(6)]
assert plist(l.call([conslist(list1_w),
conslist(list2_w)])) == list1_w + list2_w
def test_catch_all(self):
var = Variable("x")
pat = pattern(var)
w_obj = cons("barf")
binding = [None]
var.binding_index = 0
pat.match(w_obj, binding)
assert binding[var.binding_index] == w_obj
def test_muffle(self):
for i in range(20):
vars = [Variable("x%s" % n) for n in range(i)]
vars2 = [Variable("x%s" % n) for n in range(i - 1)]
m = lamb((vars2, cons("cons", *vars2)))
m._name = "construct"
l = lamb()
l._name = "muffle%s" % i
l._rules = ziprules(([cons("cons", *vars)], mu(m, vars[1:])))
list1 = [integer(n) for n in range(i)]
w_cons1 = cons("cons", *list1)
res = l.call([w_cons1])
assert res == cons("cons", *(list1[1:]))
def test_constructor_with_int(self):
for num in range(0, 12):
w_int = integer(1)
w_children = [w_int] * num
w_cons = cons("zork", *w_children)
expr = expression(w_cons)
binding = []
w_res = expr.evaluate_with_binding(binding)
assert w_res == w_cons
def test_append(self):
x1 = Variable("x")
x2 = Variable("x")
h = Variable("head")
t = Variable("tail")
l = lamb()
l._name = "append"
l._rules = ziprules(
([nil(), x1], x1),
([cons("cons", h, t), x2], cons("cons", h, mu(l, [t, x2]))))
list1_w = [integer(1), integer(2), integer(3)]
list2_w = [integer(4), integer(5), integer(6)]
res = interpret_expression(
mu(l, [conslist(list1_w), conslist(list2_w)]))
assert plist(res) == list1_w + list2_w
def test_constructor_with_var(self):
var = Variable("x")
var.binding_index = 0
w_cons = cons("zork", var)
w_int = integer(1)
expr = expression(w_cons)
binding = [w_int]
w_res = expr.evaluate_with_binding(binding)
assert w_res.get_child(0) == w_int
def make_reverse():
a1 = Variable("acc")
a2 = Variable("acc")
h = Variable("head")
t = Variable("tail")
reverse_acc = lamb()
reverse_acc._name = "r_acc"
reverse_acc._rules = rules([([p(nil()), p(a1)], e(a1)),
([p(cons("cons", h, t)),
p(a2)],
e(mu(reverse_acc,
[t, cons("cons", h, a2)])))])
l = Variable("list")
reverse = lamb()
reverse._rules = rules([([p(l)], mu(reverse_acc, [l, nil()]))])
reverse._name = "reverse"
return reverse
def test_complex(self):
var1 = Variable("x")
var1.binding_index = 0
var2 = Variable("y")
var2.binding_index = 1
var3 = Variable("z")
var3.binding_index = 2
var4 = Variable("a")
var4.binding_index = 3
var5 = Variable("b")
var5.binding_index = 4
var6 = Variable("c")
var6.binding_index = 5
w_int1 = integer(1)
w_int2 = integer(2)
w_int3 = integer(3)
w_cons1 = cons("zork")
w_cons2 = cons("barf", w_int1, w_int2)
w_cons3 = cons("moep", w_cons1)
expr1 = expression(cons("universe", var1, var2))
expr2 = expression(cons("moep", var3))
expr3 = expression(cons("universe", cons("barf", var4, var5), var6))
binding = [w_cons2, w_cons3, w_cons1, w_cons2, w_cons3, w_cons1]
w_res = expr1.evaluate_with_binding(binding)
assert w_res.get_tag() is tag("universe", 2)
w_child0 = w_res.get_child(0)
assert w_child0.get_tag() is tag("barf", 2)
assert w_child0.get_child(0) is w_int1
assert w_child0.get_child(1) is w_int2
w_child1 = w_res.get_child(1)
assert w_child1.get_tag() is tag("moep", 1)
assert w_child1.get_child(0).get_tag() is tag("zork", 0)
w_res = expr2.evaluate_with_binding(binding)
assert w_res.get_tag() is tag("moep", 1)
w_child0 = w_res.get_child(0)
assert w_child0.get_tag() is tag("zork", 0)
w_res = expr3.evaluate_with_binding(binding)
assert w_res.get_tag() is tag("universe", 2)
w_child0 = w_res.get_child(0)
assert w_child0.get_tag() is tag("barf", 2)
w_child00 = w_child0.get_child(0)
assert w_child00.get_tag() is tag("barf", 2)
assert w_child00.get_child(0) is w_int1
assert w_child00.get_child(1) is w_int2
w_child01 = w_child0.get_child(1)
assert w_child01.get_tag() is tag("moep", 1)
assert w_child01.get_child(0).get_tag() is tag("zork", 0)
w_child1 = w_res.get_child(1)
assert w_child1.get_tag() is tag("zork", 0)
def peano_num(pynum):
i = 0
res = nil()
shape = None
#peano_jit.can_enter_jit(num=pynum, shape=shape, i=i, res=res)
while i < pynum:
shape = res._shape
#peano_jit.jit_merge_point(num=pynum, shape=shape, i=i, res=res)
res = cons("p", res)
i += 1
return res
def test_nary_constructors(self):
for i in range(12):
w_children = [integer(n) for n in range(i)]
w_res = cons("zork", *w_children)
assert isinstance(w_res, W_Constructor)
assert w_res.get_tag() is tag("zork", len(w_children))
assert w_res.get_number_of_children() is i
if i > 0:
assert w_res.get_child(i - 1) == integer(i - 1)
with py.test.raises(IndexError) as e:
w_res.get_child(i)
def test_map(self):
"""
in scheme
(define (map proc lis)
(cond ((null? lis)
'())
((pair? lis)
(cons (proc (car lis))
(map proc (cdr lis))))))
nil ≔ (nil)
map ≔ λ:
F, (cons X, Y) ↦ (cons μ(F, X), μ(map, F, Y))
_, nil ↦ nil
"""
from mu.peano import startup_peano, _succ
startup_peano()
f = Variable("F")
x = Variable("X")
y = Variable("Y")
_ = Variable("_")
_2 = Variable("_")
m = lamb()
m._name = "map"
m._rules = ziprules(
([f, cons("cons", x, y)], cons("cons", mu(f, [x]), mu(m, [f, y]))),
([_, nil()], nil()))
x1 = Variable("x")
list_w = [peano_num(1), peano_num(2), peano_num(3)]
#list_w = [peano_num(1)]
res = interpret_expression(mu(m, [_succ(), conslist(list_w)]))
assert plist(res) == [peano_num(2), peano_num(3), peano_num(4)]
def test_nested_constructor(self):
pat = pattern(cons("barf", cons("zork")))
w_obj = cons("barf", cons("zork"))
binding = []
pat.match(w_obj, binding)
assert binding == []
w_obj = cons("barf", cons("moep"))
with py.test.raises(NoMatch) as e:
pat.match(w_obj, binding)
def test_complex(self):
var1 = Variable("x")
var1.binding_index = 0
var2 = Variable("y")
var2.binding_index = 1
var3 = Variable("z")
var3.binding_index = 2
var4 = Variable("a")
var4.binding_index = 3
var5 = Variable("b")
var5.binding_index = 4
var6 = Variable("c")
var6.binding_index = 5
w_int1 = integer(1)
w_int2 = integer(2)
w_int3 = integer(3)
w_cons1 = cons("zork")
w_cons2 = cons("barf", w_int1, w_int2)
w_cons3 = cons("moep", w_cons1)
w_cons4 = cons("universe", w_cons2, w_cons3)
pat1 = pattern(cons("universe", var1, var2))
pat2 = pattern(cons("moep", var3))
pat3 = pattern(cons("universe", cons("barf", var4, var5), var6))
binding = [None] * 6
pat1.match(w_cons4, binding)
assert binding[var1.binding_index] == w_cons2
assert binding[var2.binding_index] == w_cons3
binding = [None] * 6
pat2.match(w_cons3, binding)
assert binding[var3.binding_index] == w_cons1
binding = [None] * 6
pat3.match(w_cons4, binding)
assert binding[var4.binding_index] == w_int1
assert binding[var5.binding_index] == w_int2
assert binding[var6.binding_index] == w_cons3
def make_gc_bench():
w_tStart_v0 = Variable("tStart")
w_tStart_v1 = Variable("tStart")
w_tStart_v2 = Variable("tStart")
w_tFinish_v0 = Variable("tFinish")
w_root_v0 = Variable("root")
w_root_v1 = Variable("root")
w_kStretchTreeDepth_v0 = Variable("kStretchTreeDepth")
w_iDepth_v0 = Variable("iDepth")
w_Make_Tree = lamb()
w_Make_Tree._name = "MakeTree"
w_Make_Tree._rules = rules([
([p(integer(0))], e(cons("Node", nil(), nil()))),
([p(w_iDepth_v0)],
e(
cons("Node",
mu(w_Make_Tree,
[mu(_minus(), [w_iDepth_v0, integer(1)])]),
mu(w_Make_Tree,
[mu(_minus(), [w_iDepth_v0, integer(1)])]))))
])
w_gc_bench_cont1 = lamb()
w_gc_bench_cont1._name = "gc_bench$cont0"
w_gc_bench_cont1._rules = rules([(
[p(w_tStart_v2), p(w_tFinish_v0),
p(w_root_v1)], # we 'un-reference'
e(mu(_print_int(), [mu(_minus(), [w_tFinish_v0, w_tStart_v2])])))])
w_gc_bench_cont0 = lamb()
w_gc_bench_cont0._name = "gc_bench$cont0"
w_gc_bench_cont0._rules = rules([([p(w_tStart_v1),
p(w_root_v0)],
e(
mu(w_gc_bench_cont1, [
w_tStart_v1,
mu(_currentmilliseconds(), []),
w_root_v0,
])))])
w_gc_bench_let0 = lamb()
w_gc_bench_let0._name = "gc_bench$let0"
w_gc_bench_let0._rules = rules([
([p(w_kStretchTreeDepth_v0), p(w_tStart_v0)],
e(
mu(w_gc_bench_cont0,
[w_tStart_v0,
mu(w_Make_Tree, [w_kStretchTreeDepth_v0])])))
])
w_gc_bench = lamb()
w_gc_bench._name = "gc_bench"
w_gc_bench._rules = rules([(
[],
e(
mu(
w_gc_bench_let0,
[
integer(18), # kStretchTreeDepth
mu(_currentmilliseconds(), []), # tStart
])))])
return w_gc_bench
def test_empty_constructor(self):
w_res = cons("zork")
assert isinstance(w_res, W_Constructor)
assert w_res.get_tag() is tag("zork", 0)
assert w_res.get_number_of_children() is 0
def test_still_simple_constructor(self):
w_res = cons("zork", integer(1), integer(2))
assert isinstance(w_res, W_Constructor)
assert w_res.get_tag() is tag("zork", 2)
assert w_res.get_number_of_children() is 2
