def test_transformation_of_result(self):
mod = Module([Parser.rule("a() --> b where b => 2")])
term = Parser.term("a()")
result = Interpreter(mod).interpret(term)
self.assertEqual(result, IntTerm(2))
def test_one_transformation(self):
mod = Module([Parser.rule("a(x) --> b where x == 1")])
term = Parser.term("a(1)")
result = Interpreter(mod).interpret(term)
self.assertEqual(result, VarTerm("b"))
def test_block(self):
mod = Module([Parser.rule("block([x | xs]) --> block(xs)")])
term = Parser.term("block([1, 2, 3, 4])")
result = Interpreter(mod).interpret(term)
self.assertEqual(result, ApplTerm("block"))
def test_invalid_premise(self):
mod = Module([Parser.rule("a() --> b() where 1 == 2")])
term = Parser.term("a()")
with self.assertRaises(DynsemError):
Interpreter(mod).interpret(
term) # does not know where to go when 1 != 2
def test_native(self):
add = NativeFunction(Parser.native_function("add(x, y)"),
lambda x, y: x + y)
mod = Module([Parser.rule("a(x) --> add(x, 1)")], [add])
term = Parser.term("a(1)")
result = Interpreter(mod).interpret(term)
self.assertEqual(result, IntTerm(2))
def test_environment_retrieval(self):
mod = Module([Parser.rule("E |- read(y) --> E[y]")])
term = Parser.term("read(y)")
sut = Interpreter(mod)
sut.environment.locate_and_put("y", 42)
result = sut.interpret(term)
self.assertEqual(result, 42)
def test_reduction_premise(self):
mod = Module([
Parser.rule("b() --> c()"),
Parser.rule("a(x) --> y where x --> y")
])
term = Parser.term("a(b())")
result = Interpreter(mod).interpret(term)
self.assertEqual(result, ApplTerm("c"))
def test_environment_assignment(self):
mod = Module([Parser.rule("E |- bindVar(k, v) --> {k |--> v, E}")])
term = Parser.term("bindVar(a, 1)")
sut = Interpreter(mod)
a = sut.environment.locate_and_put(
"a", IntTerm(42)) # this should be overwritten
result = sut.interpret(term)
self.assertIsInstance(result, MapWriteTerm)
self.assertEqual(IntTerm(1), sut.environment.get(a))
def test_multiple_transformations(self):
mod = Module([
Parser.rule("a() --> b()"),
Parser.rule("b() --> c()"),
Parser.rule("c() --> d()")
])
term = Parser.term("a()")
result = Interpreter(mod).interpret(term)
self.assertEqual(result, Parser.term("d()"))
def test_interpreter_caching(self):
if_rule = Parser.rule("if(a) --> then(a)")
then1_rule = Parser.rule("then(0) --> b")
then2_rule = Parser.rule("then(x) --> c")
module = Module([if_rule, then1_rule, then2_rule])
interpreter = Interpreter(module)
result1 = interpreter.interpret(Parser.term("if(0)"))
self.assertEqual(VarTerm("b"), result1)
result2 = interpreter.interpret(Parser.term("if(1)"))
self.assertEqual(VarTerm("c"), result2)
def test_recursive_contexts(self):
ifz_rule = Parser.rule(
"ifz(cond, then, else) --> ifzc(value, then, else) where cond --> value"
)
ifz0_rule = Parser.rule("ifzc(0, then, else) --> then")
ifz1_rule = Parser.rule("ifzc(nonzero, then, else) --> else")
# TODO need inequality check, e.g. where non_zero != 0
module = Module([ifz_rule, ifz0_rule, ifz1_rule])
interpreter = Interpreter(module)
result = interpreter.interpret(Parser.term("ifz(ifz(1, 2, 3), 4, 5)"))
self.assertEqual(IntTerm(5), result)
Parser.rule("E |- retrieve(x) --> E[x]"),
# TODO rename this to something other than ifz... it is not an ifz
Parser.rule(
"ifz(cond, then, else) --> result where cond --> cond2; case cond2 of {0 => result => else otherwise => result => then}"
),
while_rule,
Parser.rule("while2(cond, 0, then) --> 0"),
Parser.rule(
"while2(cond, value, then) --> while(cond, then) where then --> ignored"
)
]
def write(s, unused):
print(s)
return 0
native_functions = [
NativeFunction(Parser.native_function("write(x)"),
write), # TODO rpython demands it
NativeFunction(Parser.native_function("add(x, y)"), lambda x, y: x + y),
NativeFunction(Parser.native_function("sub(x, y)"), lambda x, y: x - y),
NativeFunction(Parser.native_function("mul(x, y)"), lambda x, y: x * y),
NativeFunction(Parser.native_function("div(x, y)"), lambda x, y: x // y),
NativeFunction(Parser.native_function("leq(x, y)"),
lambda x, y: int(x <= y))
]
e2 = Module(rules, native_functions)