def test_lambda_patternless(self, parser):
t = parser.parse("""λ. 1. ↦ 1""")
# lambdas cannot compare equal meaningfully
assert t[0]._rules == [
expression.Rule(patterns=[], expression=model.w_integer(1))
]
# should work, but meaningless
t = parser.parse("""λ.
1. ↦ 1
2. ↦ 2
""")
assert t[0]._rules == [
expression.Rule(patterns=[], expression=model.w_integer(1)),
expression.Rule(patterns=[], expression=model.w_integer(2))
]
def test_variable(self, parser):
with py.test.raises(ParseError) as e:
t = parser.parse("foo")
assert e.value.source_pos == SourcePos(0, 0, 0)
assert e.value.errorinformation == 'Unbound variable foo'
t = parser.parse("""
foo ≔ 1
foo
""")
assert t == [model.W_Object(), model.w_integer(1)]
def div(w_x, w_y):
if isinstance(w_x, model.W_Integer) and isinstance(w_y, model.W_Integer):
return div_int(w_x.value(), w_y.value())
elif isinstance(w_x, model.W_Integer) and isinstance(w_y, model.W_Float):
return div_float(float(w_x.value()), w_y.value())
elif isinstance(w_x, model.W_Float) and isinstance(w_y, model.W_Integer):
return div_float(w_x.value(), float(w_y.value()))
elif isinstance(w_x, model.W_Float) and isinstance(w_y, model.W_Float):
return div_float(w_x.value(), w_y.value())
else:
assert False
return model.w_integer(w_x / w_y)
def test_lambda_solo(self, parser):
t = parser.parse("""λ. ↦ 1""")
# lambdas cannot compare equal meaningfully
assert t[0]._rules == [
expression.Rule(patterns=[], expression=model.w_integer(1))
]
t = parser.parse("""λ. x ↦ x""")
# lambdas cannot compare equal meaningfully
x = Variable("x")
assert t[0]._rules == [
expression.Rule(patterns=[p(x)], expression=e(x))
]
assert t[0]._rules[0]._patterns[0].variable is \
t[0]._rules[0]._expression.variable
def test_primary(self, parser):
t = parser.parse("")
assert t == []
t = parser.parse("1")
assert t == [model.w_integer(1)]
t = parser.parse("‘’")
assert t == [model.w_string("")]
t = parser.parse("“”")
assert t == [model.w_string("")]
t = parser.parse("‘1’")
assert t == [model.w_string("1")]
t = parser.parse("“1”")
assert t == [model.w_string("1")]
def test_lambda_simple_pattern(self, parser):
t = parser.parse("""λ. 1. 1 ↦ 5""")
# lambdas cannot compare equal meaningfully
assert t[0]._rules == [
expression.Rule(patterns=[p(model.w_integer(1))],
expression=e(model.w_integer(5)))
]
# should work, but meaningless
t = parser.parse("""λ.
1. 1 ↦ 4
2. 2 ↦ 12345
""")
assert t[0]._rules == [
expression.Rule(patterns=[p(model.w_integer(1))],
expression=e(model.w_integer(4))),
expression.Rule(patterns=[p(model.w_integer(2))],
expression=e(model.w_integer(12345)))
]
t = parser.parse("""λ. 1. x ↦ x""")
# lambdas cannot compare equal meaningfully
x = Variable("x")
assert t[0]._rules == [
expression.Rule(patterns=[p(x)], expression=e(x))
]
assert t[0]._rules[0]._patterns[0].variable is \
t[0]._rules[0]._expression.variable
# should work, but meaningless
t = parser.parse("""λ.
1. x ↦ x
2. x ↦ 4
""")
x1 = Variable("x")
x2 = Variable("x")
assert t[0]._rules == [
expression.Rule(patterns=[p(x1)], expression=e(x1)),
expression.Rule(patterns=[p(x2)], expression=e(model.w_integer(4)))
]
assert t[0]._rules[0]._patterns[0].variable.name == \
t[0]._rules[1]._patterns[0].variable.name
assert t[0]._rules[0]._patterns[0].variable is not \
t[0]._rules[1]._patterns[0].variable
def string_to_int(s):
return model.w_integer(
rarithmetic.string_to_int(rstring.replace(s, "_", ""), base=0))
def lsr(x, y):
return model.w_integer(x >> y)
def lsl(x, y):
return model.w_integer(x << y)
def mod_int(x, y):
return model.w_integer(x % y)
def div_int(x, y):
return model.w_integer(x / y)
def mult_int(x, y):
return model.w_integer(x * y)
def plus_int(x, y):
return model.w_integer(x + y)
def minus_int(x, y):
return model.w_integer(x - y)
def currentmilliseconds():
import time
return model.w_integer(int(time.clock() * 1000))
