예제 #1
0
def test_lambda(std_env: Environment) -> None:
    source = '(lambda (a b) (if (>= a b) a b))'
    func = evaluate(parse(source), std_env)
    assert func.parms == ['a', 'b']
    assert func.body == [['if', ['>=', 'a', 'b'], 'a', 'b']]
    assert func.env is std_env
    assert func(1, 2) == 2
    assert func(3, 2) == 3
예제 #2
0
def test_begin(std_env: Environment) -> None:
    source = """
        (begin
            (define x (* 2 3))
            (* x 7)
        )
        """
    got = evaluate(parse(source), std_env)
    assert got == 42
예제 #3
0
def test_invocation_user_procedure(std_env: Environment) -> None:
    source = """
        (begin
            (define max (lambda (a b) (if (>= a b) a b)))
            (max 22 11)
        )
        """
    got = evaluate(parse(source), std_env)
    assert got == 22
예제 #4
0
def test_define_function(std_env: Environment) -> None:
    source = '(define (max a b) (if (>= a b) a b))'
    got = evaluate(parse(source), std_env)
    assert got is None
    max_fn = std_env['max']
    assert max_fn.parms == ['a', 'b']
    assert max_fn.body == [['if', ['>=', 'a', 'b'], 'a', 'b']]
    assert max_fn.env is std_env
    assert max_fn(1, 2) == 2
    assert max_fn(3, 2) == 3
예제 #5
0
def callJSON(func):
	global r20functions
	if func.get('type')=='lisp':
		if lis:
			lis.eval(lis.parse(str(func['content'])))
		else:
			sendMsgToR20('Cannot execute lisp function, lisp functions rely on lispy2 by Peter Norvig, available here:  http://norvig.com/lispy2.html')
	else:
		r20functions=reload(r20functions)
		r20functions.getFunc(func['name'])(func)
예제 #6
0
def callJSON(func):
    global r20functions
    if func.get('type') == 'lisp':
        if lis:
            lis.eval(lis.parse(str(func['content'])))
        else:
            sendMsgToR20(
                'Cannot execute lisp function, lisp functions rely on lispy2 by Peter Norvig, available here:  http://norvig.com/lispy2.html'
            )
    else:
        r20functions = reload(r20functions)
        r20functions.getFunc(func['name'])(func)
예제 #7
0
def test(task_name, func_string, subset='train'):
    with open(f'ARC/data/training/{task_name}.json') as f:
        j = json.load(f)

    prog = parse(func_string)

    correct = True
    for i, t in enumerate(j[subset]):
        input_grid = np.array(t['input'])
        prog_with_input = ['define', 'grid', input_grid, prog]
        pred = eval(prog_with_input)
        #print(pred)
        # vis(pred)
        target = np.array(t['output'])
        correct &= match(pred, target)

    return correct
예제 #8
0
def test_invocation_builtin_car(std_env: Environment) -> None:
    source = '(car (quote (11 22 33)))'
    got = evaluate(parse(source), std_env)
    assert got == 11
예제 #9
0
def test_invocation_builtin_append(std_env: Environment) -> None:
    source = '(append (quote (a b)) (quote (c d)))'
    got = evaluate(parse(source), std_env)
    assert got == ['a', 'b', 'c', 'd']
예제 #10
0
 def test_define_exp(self):
     self.assertEqual(parse('(begin (define r 3) (+ r 5))'),
                      ['begin', ['define', 'r', 3], ['+', 'r', 5]])
예제 #11
0
 def test_even_more_more_nested_exp(self):
     self.assertEqual(
         parse('(begin (+ (+ 3 6) (- 3 2) (+ (- 1 1) 3)))'),
         ['begin', ['+', ['+', 3, 6], ['-', 3, 2], ['+', ['-', 1, 1], 3]]])
예제 #12
0
def test_evaluate_if_false(std_env: Environment) -> None:
    source = '(if 0 no-such-thing 20)'
    expected = 20
    got = evaluate(parse(source), std_env)
    assert got == expected
예제 #13
0
def test_define(std_env: Environment) -> None:
    source = '(define answer (* 6 7))'
    got = evaluate(parse(source), std_env)
    assert got is None
    assert std_env['answer'] == 42
예제 #14
0
def mainloop(statements):
    for statement in statements:
        if len(statement) != 0:
            tokens = parse(statement)
            print(eval(tokens))
예제 #15
0
파일: lis_tests.py 프로젝트: tartley/lispy
 def test_parse_multiple_expr(self):
     self.assertEqual(list(parse('(1 2)(3)')), [[1, 2], [3]])
예제 #16
0
def test_parse(source: str, expected: Expression) -> None:
    got = parse(source)
    assert got == expected
예제 #17
0
def test_evaluate_variable() -> None:
    env: Environment = dict(x=10)
    source = 'x'
    expected = 10
    got = evaluate(parse(source), env)
    assert got == expected
예제 #18
0
def test_evaluate_variable():
    env = dict(x=10)
    source = 'x'
    expected = 10
    got = evaluate(parse(source), env)
    assert got == expected
예제 #19
0
def test_evaluate(source, expected):
    got = evaluate(parse(source), global_env_for_first_test)
    assert got == expected
예제 #20
0
def test_parse(source: str, expected):
    got = parse(source)
    assert got == expected
예제 #21
0
def test_invocation_builtin_map(std_env: Environment) -> None:
    source = '(map (lambda (x) (* x 2)) (quote (1 2 3))))'
    got = evaluate(parse(source), std_env)
    assert got == [2, 4, 6]
예제 #22
0
 def test_nested_exp(self):
     self.assertEqual(parse('(begin (+ 1 (- 3 2)))'),
                      ['begin', ['+', 1, ['-', 3, 2]]])
예제 #23
0
def test_evaluate_literal(std_env):
    source = '3.3'
    expected = 3.3
    got = evaluate(parse(source), std_env)
    assert got == expected
예제 #24
0
파일: lis_tests.py 프로젝트: tartley/lispy
 def test_parse_single_expr(self):
     self.assertEqual(list(parse('(1 2 3)')), [[1, 2, 3]])
예제 #25
0
def test_evaluate(source: str, expected: Optional[Expression]) -> None:
    got = evaluate(parse(source), global_env_for_first_test)
    assert got == expected
예제 #26
0
def test_evaluate_quote(std_env: Environment) -> None:
    source = '(quote (1.1 is not 1))'
    expected = [1.1, 'is', 'not', 1]
    got = evaluate(parse(source), std_env)
    assert got == expected
예제 #27
0
def test_evaluate_literal(std_env: Environment) -> None:
    source = '3.3'
    expected = 3.3
    got = evaluate(parse(source), std_env)
    assert got == expected
예제 #28
0
def test_evaluate_if_true(std_env: Environment) -> None:
    source = '(if 1 10 no-such-thing)'
    expected = 10
    got = evaluate(parse(source), std_env)
    assert got == expected
예제 #29
0
파일: player.py 프로젝트: 0atman/THE-GRID
    def notes(self, world, *args):
        if not self.__dict__.get('note_store'):
            self.note_store = []
            self.save()
        if len(args) == 0:
            if self.note_store:
                for n, note in enumerate(self.note_store):
                    print("note #" + str(n) + "\n" + note.split('\n')[0])
            else:
                print("No notes.")

        elif len(args) > 0:
            if str(args[0]).lower() in ['new', 'create', 'write', 'add']:
                self.writenote()
                return
            if str(args[0]).lower() in ['delete', 'del', 'rm']:
                try:
                    del self.note_store[int(args[1])]
                    self.save()
                    print('Deleted.')
                except ValueError:
                    print("Bad note ID.")
                except IndexError:
                    print("Can't find that note ID")
                return
            if str(args[0]).lower() in ['run']:
                try:
                    for line in self.note_store[int(args[1])].split('\n'):
                        val = lis.eval(lis.parse(line))
                        if val:
                            print(lis.lispstr(val))
                    print()
                except IndexError:
                    print("Can't find that note ID")
                return
            if str(args[0]).lower() in ['drop']:
                try:
                    dropped_note = self.note_store[int(args[1])]
                    del self.note_store[int(args[1])]
                    self.save()
                    room_data = get_room(self.x, self.y)
                    if not room_data.get('data'):
                        room_data['data'] = []
                    room_data['data'].append(dropped_note)

                    put_room(self.x, self.y, room_data)
                except ValueError:
                    raise  # print("Bad note ID.")
                except IndexError:
                    raise  # print("Can't find that note ID")
                return
            elif type(args[0]) == int:
                try:
                    print(
                        "note #" +
                        str(args[0]) + " " +
                        self.note_store[int(args[0])]
                    )
                    return
                except ValueError:
                    print("Bad note ID.")
                    return
                except IndexError:
                    print("Can't find that note ID")
                    return
예제 #30
0
 def test_simple_exp(self):
     self.assertEqual(parse('(begin (+ 1 2))'), ['begin', ['+', 1, 2]])