def testRecursiveReturnValue3(self):
E, e, e1, e2 = Var('E'), Var('e'), Var('e1'), Var('e2')
ruleList = [(E,
function(((e, 1), E(e, 2)), ((e, 2), char(e)),
(((e1, e2), 1), E(e1, 2), E(e2, 1))))]
eq_(eval(letr(ruleList, parse_text(E(e, 1) + eoi, '12'), e)),
('1', '2'))
def testoptionalcut(self):
x, s = Var('x'), Var('s')
ruleList = [(s, function(((x, ), and_p(-char('a'), cut, char(x)))))]
eq_(eval(let(ruleList, parse_text(s(x), 'aa'), x)), 'a')
eq_(eval(let(ruleList, parse_text(s(x), 'b'), x)), 'b')
assert_raises(NoSolution, eval, let(ruleList, parse_text(s(x), 'a'),
x))
def testembedvar2(self):
e, e2, f, g, h = Var('e'), Var('e2'), Var('f'), Var('g'), Var('h')
eq_(
eval(
letrec([(f, macro([[cons(1, e2)], g(e2)])),
(g, function([[e], h(e)])),
(h, function([[1], True]))], f(e), e)), cons(1, 1))
def test_findall_or_p(self):
x, y = Var('x'), Var('y')
eq_(
eval(
findall(
macrorules([[x, y], x], [[x, y], y])(prin(1), prin(2)))),
None)
def test_some(self):
X, Y = Var('X'), Var('Y')
eq_(eval(begin(parse_text(some(char(X), X, Y), '222'), Y)),
['2', '2', '2'])
eq_(eval(begin(parse_text(some(char(X), X, Y), '234'), Y)), ['2'])
assert_raises(NoSolution, eval,
begin(parse_text(some(char(X), X, Y), ''), Y))
def test_findall2(self):
cut_or_cont = il.Var('cut_or_cont')
x, y = Var('x'), Var('y')
findall_result = il.Var('findall_result')
result = cps(findall(or_(1, 2), x, y))
expect = 1
eq_(result, expect)
def test_any_some(self):
X, Y = Var('X'), Var('Y')
eq_(
eval(
begin(
parse_text(
char(X) + any(~char('b') + some(char(X))) + eoi,
'abaaaa'), X)), 'a')
def test_right_recursive2(self):
x, p = Var('x'), Var('p')
function1 = [(p, function(((), and_p(char(x), p())), ((), char(x))))]
eq_(
eval(
letr(function1, parse_text(p(), 'a'), parse_text(p(), 'ab'),
parse_text(p(), 'abc'))), 'c')
assert_raises(NoSolution, eval, letr(function1, parse_text(p(), '')))
def testCut1(self):
a, b, c, x = Var('a'), Var('b'), Var('c'), Var('x')
Lx = LogicVar('x')
eq_(
eval(
letrec([(a, rules([[x], begin(b(x), cut, c(x))])),
(b, rules([[1], True], [[2], True], [[3], True])),
(c, rules([[1], True]))], a(Lx), getvalue(Lx))), 1)
def test_chars(self):
x, cs, chars = LogicVar('x'), Var('cs'), MacroVar('chars')
x1 = Var('x')
eq_(
eval(
let([(chars, lamda(
(x1, cs), begin(char(x1), contain(cs, x1))))],
parse_text(chars(x, 'a'), 'a'), getvalue(x))), 'a')
def test_times_a2(self):
X, Y, S = Var('X'), Var('Y'), Var('S')
function1 = function(((Y, ), times(char('a'), 2, 'a', Y)))
eq_(eval(begin(parse_text(function1(X), 'aa'), X)), ['a', 'a'])
assert_raises(NoSolution, eval, begin(parse_text(function1(X), 'a'),
X))
assert_raises(NoSolution, eval,
begin(parse_text(and_p(function1(X), eoi), 'aaa'), X))
def test_cut2(self):
a, b, c, x = Var('a'), Var('b'), Var('c'), Var('x')
Lx = LogicVar('x')
assert_raises(
NoSolution, eval,
letrec([(a, rules([[x], begin(b(x), cut, c(x))])),
(b, rules([[1], True], [[2], True], [[3], True])),
(c, rules([[2], True]))], a(Lx), getvalue(Lx)))
def test_macro6(self):
n, act, ntimes = Var('n'), Var('act'), MacroVar('ntimes')
eq_(
eval(
letrec([(ntimes,
macro((n, act),
if_(eq(n, 0), 1,
begin(act, ntimes(sub(n, 1), act)))))],
ntimes(3, println(1)))), 1)
def testblock(self):
f = Var('f')
foo = Var('foo')
eq_(
eval(
block(
foo,
let([(f, lamda((), exit_block(foo, 1)))],
mul(2, block(foo, f()))))), 1)
def test_cut2_no_Cut3_begin(self):
a, b, c, d, x = Var('a'), Var('b'), Var('c'), Var('d'), Var('x')
Lx = LogicVar('x')
eq_(
eval(
letrec([(a, rules([[x], begin(b(x), c(x))], [[x], d(x)])),
(b, rules([[1], 'b1'], [[4], 'b4'])),
(c, rules([[4], 'c4'])), (d, rules([[3], 'd3']))],
a(Lx), getvalue(Lx))), 4)
def testCut4(self):
a, b, c, d, x = Var('a'), Var('b'), Var('c'), Var('d'), Var('x'),
Lx = LogicVar('x')
assert_raises(
NoSolution, eval,
letrec([(a, rules([[x], begin(b(x), cut, c(x))], [[x], d(x)])),
(b, rules([[1], 'b1'], [[4], 'b4'])),
(c, rules([[4], 'c4'])), (d, rules([[3], 'd3']))], a(Lx),
getvalue(Lx)))
def test_unify_right_recursive(self):
x, p = Var('x'), Var('p')
function1 = [(p,
function(((x, ), and_p(char(x), p(x))),
((x, ), char(x))))]
eq_(eval(letr(function1, parse_text(p(x), 'aa'))), 'a')
eq_(eval(letr(function1, parse_text(p(x), 'a'))), 'a')
assert_raises(NoSolution, eval,
letr(function1, parse_text(and_p(p(x), eoi), 'xy')))
assert_raises(NoSolution, eval, letr(function1, parse_text(p(x), '')))
def testOr(self):
x, s, one, two = Var('x'), Var('s'), Var('one'), Var('two')
ruleList = [(s, function(((x, ), or_p(one(x), two(x))))),
(one, function((('1', ), char('1')))),
(two, function((('2', ), char('2'))))]
eq_(eval(letr(ruleList, parse_text(s(x), '1'))), '1')
eq_(eval(letr(ruleList, parse_text(s(y), '2'))), '2')
assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '3')))
assert_raises(NoSolution, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), '12')))
assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '')))
def testIndentUndent(self):
_, n, s, line = DummyVar('_'), Var('n'), Var('s'), Var('line')
space = char(' ')
ruleList = [(s,
function(((n, ), some(line(n)), s(add(n, 1))),
((n, ), some(line(n))))),
(line,
function(((n, ), times(space, n), some(letter(_)),
any(space), char('\n'))))]
eq_(eval(letr(ruleList, parse_text(s(0), 'a\n b\n c\n'))), True)
eq_(eval(letr(ruleList, parse_text(s(0), 'asd\n bdf\n cdfh\n'))), True)
def testKleene1(self): #occurs_check
x, s, kleene = Var('x'), Var('s'), Var('kleene')
x1 = Var('x')
result = LogicVar('result')
ruleList = [(kleene,
rules(((cons('a', x), ), begin(char('a'), kleene(x))),
((nil, ), nullword)))]
eq_(
eval(
letrec(ruleList, parse_text(kleene(result), 'aa'),
getvalue(result))), L('a', 'a'))
def testparallelRule(self):
x, s, gt, lt = Var('x'), Var('s'), Var('>'), Var('<')
ruleList = [(s, function(((x, ), parallel(gt(x, 3), lt(x, 5))))),
(gt, function(((4, 3), char('4')))),
(lt, function(((4, 5), char('4'))))]
eq_(eval(letr(ruleList, parse_text(s(x), '4'), x)), 4)
assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '6'),
x))
assert_raises(NoSolution, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), ''),
x))
def xxxtest_left_recursive(self):
assert 0, 'a good idea is waiting to be implemented'
assert 0, 'googd idea failed!'
engine = Engine()
X = Var()
f = userTerm("f")
engine.add_rule(rule(f(X), f(X) + char('1')))
engine.add_rule(rule(f(X), char('2')))
X = Var()
engine.run(f(X), '21')
engine.run(f(X), '2')
assert_raises(UnifyFail, engine.run, f(X), '1')
def testKleene4(self):
x, _, c, s, kleene = Var('x'), DummyVar('_'), Var('c'), Var('s'), Var(
'kleene')
ruleList = [(s, function(((x, ), kleene(_, x)))),
(kleene,
function(((_, Cons(c, x)), char(c) & kleene(_, x)),
((_, nil), nullword)))]
eq_(eval(letr(ruleList, parse_text(s(x), 'a'), x)), L('a'))
eq_(eval(letr(ruleList, parse_text(s(x), 'aa'), x)), L('a', 'a'))
eq_(eval(letr(ruleList, parse_text(s(x), 'aaa'), x)), L('a', 'a', 'a'))
eq_(eval(letr(ruleList, parse_text(s(x), 'bbb'), x)), L('b', 'b', 'b'))
eq_(eval(letr(ruleList, parse_text(s(x), 'abc'), x)), L('a', 'b', 'c'))
eq_(eval(letr(ruleList, parse_text(s(x), ''), x)), nil)
def test_cut2_no_Cut2_and_(self):
# test_cut2_no_Cut_and_p work correct.
# but this test and test_cut2_no_Cut3_begin work wrong because the bug below:
# bug in Var.getvalue/Var.setvalue:
# dont't restore the longer chain of bindings after shorten it.
a, b, c, d, x = Var('a'), Var('b'), Var('c'), Var('d'), Var('x')
Lx = LogicVar('x')
eq_(
eval(
letrec([(a, rules([[x], begin(b(x), c(x))], [[x], d(x)])),
(b, rules([[1], True], [[4], True])),
(c, rules([[4], True])), (d, rules([[3], True]))],
a(Lx), getvalue(Lx))), 4)
def test_seplist(self):
X, Y = Var('X'), Var('Y')
eq_(
eval(
begin(parse_text(seplist(char(X), char(','), X, Y), '2,2,2'),
Y)), ['2', '2', '2'])
eq_(
eval(
begin(parse_text(seplist(char(X), char(','), X, Y), '2,3,4'),
Y)), ['2'])
eq_(eval(begin(parse_text(seplist(char(X), char(','), X, Y), '2'), Y)),
['2'])
eq_(eval(begin(parse_text(seplist(char(X), char(','), X, Y), ''), Y)),
[])
def testKleene3(self):
x, c, kleene = Var('x'), Var('c'), Var('kleene')
ruleList = [(kleene,
function(((Cons(c, x), ), char(c), kleene(x)),
((nil, ), nullword)))]
eq_(eval(letr(ruleList, parse_text(kleene(x), 'a'), x)), L('a'))
eq_(eval(letr(ruleList, parse_text(kleene(x), 'aa'), x)), L('a', 'a'))
eq_(eval(letr(ruleList, parse_text(kleene(x), 'aaa'), x)),
L('a', 'a', 'a'))
eq_(eval(letr(ruleList, parse_text(kleene(x), 'bbb'), x)),
L('b', 'b', 'b'))
eq_(eval(letr(ruleList, parse_text(kleene(x), 'abc'), x)),
L('a', 'b', 'c'))
eq_(eval(letr(ruleList, parse_text(kleene(x), ''), x)), nil)
def test_dummy_any(self):
_, Y = DummyVar('_'), Var('Y')
eq_(eval(begin(parse_text(any(char(_), _, Y), '222'), Y)),
['2', '2', '2'])
eq_(eval(begin(parse_text(any(char(_), _, Y), '234'), Y)),
['2', '3', '4'])
eq_(eval(begin(parse_text(any(char(_), _, Y), ''), Y)), [])
def test_some2(self):
X = Var('X')
eq_(eval(parse_text(and_p(some(char(X)), char('4')), '224')), '4')
eq_(eval(parse_text(and_p(some(char(X)), cut, char('4')), '224')), '4')
assert_raises(
NoSolution, eval,
parse_text(and_p(some(char(X)), char('3'), char('5')), '2234'))
def testKleene2(self):
x, c, s, kleene = Var('x'), Var('c'), Var('s'), Var('kleene')
ruleList = [(s, function(((x, ), kleene(c, x)))),
(kleene,
function(((c, Cons(c, x)), and_p(char(c), kleene(c, x))),
((c, nil), nullword)))]
eq_(eval(letr(ruleList, parse_text(s(x), 'aa'), x)), L('a', 'a'))
eq_(eval(letr(ruleList, parse_text(s(x), 'aaa'), x)), L('a', 'a', 'a'))
eq_(eval(letr(ruleList, parse_text(s(x), 'bbb'), x)), L('b', 'b', 'b'))
eq_(eval(letr(ruleList, parse_text(s(x), ''), x)), nil)
assert_raises(NoSolution, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), 'aab'), x))
assert_raises(NoSolution, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), 'abc'), x))
assert_raises(NoSolution, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
def testblock3(self):
a = Var('a')
eq_(
eval(
block(a, 1,
if_(0, continue_block(a), begin(exit_block(a, 2), 3)))),
2)
