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))