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