Exemple #1
0
    def test_create_initial_env(self):
        with utils.capture() as out:
            env = glob.create_initial_env()

        self.assertEqual(env.local_stack, [])
        self.assertTrue(len(env.global_frame) > 0)
        self.assertTrue('Creating initial environment' in out[0])
Exemple #2
0
    def test_create_initial_env(self):
        with utils.capture() as out:
            env = glob.create_initial_env()

        self.assertEqual(env.local_stack, [])
        self.assertTrue(len(env.global_frame) > 0)
        self.assertTrue('Creating initial environment' in out[0])
Exemple #3
0
def repl(inprompt=stdin_read, outprompt=stdout_prn):

    try:
        env = create_initial_env()
    except EvaluationError as ex:
        log("{0}: {1}", red(type(ex).__name__, style='bold'), ex)
        log(highlight_syntax(source_view(ex.primitive)))
        sys.exit()

    env['copyright'] = left_margin(copyright())
    env['license'] = left_margin(license())
    env['help'] = left_margin(help())
    env['credits'] = left_margin(credits())

    init_readline(env)
    ready()

    parser = scheme_parser()
    count = 1
    while True:
        try:
            text = next(inprompt(count))
            for ast in parser.parseString(text, parseAll=True).asList():
                result = ast.eval(env)
                # Evaluate lazy list representations
                result = Repr(result).eval(env)
                outprompt(result, count)

            if text.strip() != '':
                print('')

        except EOFError:
            log(blue('\nBye!', style='bold'))
            break

        except KeyboardInterrupt:
            log(red('\nKeyboardInterrupt', style='bold'))

        except EvaluationError as ex:
            log("{0}: {1}", red(type(ex).__name__, style='bold'), ex)
            log(highlight_syntax(source_view(ex.primitive)))

        except ParseException as ex:
            log("{0}: {1}", red(type(ex).__name__, style='bold'), ex)

        count += 1
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import unittest
from yalix.globals import create_initial_env
from yalix.interpreter import Closure, List, Atom, Symbol, Lambda, Realize, Repr

ENV = create_initial_env()


class DestructuringBindTests(unittest.TestCase):
    def test_fixed_args(self):
        formals = List(Symbol('x'), Symbol('y'))
        params = List(Atom(3), Atom(4))
        extended_env = Closure.bind(ENV, formals, params, ENV)

        self.assertEqual(3, extended_env['x'])
        self.assertEqual(4, extended_env['y'])

    def test_required_and_variadic_args(self):
        formals = List(Symbol('x'), Lambda.VARIADIC_MARKER, Symbol('xs'))
        params = List(Atom(3), Atom(4), Atom(5), Atom(6))
        extended_env = Closure.bind(ENV, formals, params, ENV)

        self.assertEqual(3, extended_env['x'])
        self.assertEqual([4, 5, 6],
                         Realize(extended_env['xs']).eval(extended_env))

    def test_symbol_binding(self):
        pass
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import unittest
from yalix.globals import create_initial_env
from yalix.interpreter import Closure, List, Atom, Symbol, Lambda, Realize, Repr

ENV = create_initial_env()


class DestructuringBindTests(unittest.TestCase):

    def test_fixed_args(self):
        formals = List(Symbol('x'), Symbol('y'))
        params = List(Atom(3), Atom(4))
        extended_env = Closure.bind(ENV, formals, params, ENV)

        self.assertEqual(3, extended_env['x'])
        self.assertEqual(4, extended_env['y'])

    def test_required_and_variadic_args(self):
        formals = List(Symbol('x'), Lambda.VARIADIC_MARKER, Symbol('xs'))
        params = List(Atom(3), Atom(4), Atom(5), Atom(6))
        extended_env = Closure.bind(ENV, formals, params, ENV)

        self.assertEqual(3, extended_env['x'])
        self.assertEqual([4, 5, 6], Realize(extended_env['xs']).eval(extended_env))

    def test_symbol_binding(self):
        pass