Example #1
0
    def test_symbol(self):
        x = symbol('x')
        y = symbol('x')
        z = symbol(x)

        self.assertEqual(x, x)
        self.assertEqual(x, y)
        self.assertEqual(x, z)
        self.assertEqual(y, x)
        self.assertEqual(y, y)
        self.assertEqual(y, z)
        self.assertEqual(z, x)
        self.assertEqual(z, y)
        self.assertEqual(z, z)

        self.assertEqual(id(x), id(y))
        self.assertEqual(id(y), id(z))

        self.assertTrue(x is y)
        self.assertTrue(y is z)

        w = symbol('w')

        self.assertNotEqual(x, w)
        self.assertNotEqual(w, x)
        self.assertFalse(x is w)
Example #2
0
    def test_ref(self):
        a = ref(symbol('a'))
        self.assertEqual(deref(a), undefined)
        self.assertEqual(setref(a, 100), 100)
        self.assertEqual(deref(a), 100)

        self.assertEqual(repr(a), "ref(symbol('a'))")

        b = ref(symbol('b'), 101)
        self.assertEqual(deref(b), 101)
Example #3
0
    def test_dict(self):
        x = symbol('x')
        y = symbol('y')

        d = dict()
        d[x] = "cookies"
        d[y] = "cake"
        d['x'] = "chicken"
        d['y'] = "tuna"

        self.assertEqual(d[x], "cookies")
        self.assertEqual(d[y], "cake")
        self.assertEqual(d['x'], "chicken")
        self.assertEqual(d['y'], "tuna")
Example #4
0
    def test_against_str(self):
        x = symbol('x')

        self.assertFalse(x is 'x')

        self.assertNotEqual(x, 'x')
        self.assertNotEqual('x', x)
Example #5
0
    def test_attr(self):
        a = ref(symbol('a'))
        b = attr(symbol('b'), a._get_value, a._set_value)

        self.assertEqual(deref(a), deref(b))
        self.assertEqual(deref(b), undefined)

        self.assertEqual(setref(b, 101), 101)
        self.assertEqual(deref(b), 101)
        self.assertEqual(deref(a), 101)

        self.assertEqual(setref(a, 102), 102)
        self.assertEqual(deref(b), 102)
        self.assertEqual(deref(a), 102)

        c = attr(symbol('c'), a._get_value)

        self.assertEqual(deref(c), 102)

        with self.assertRaises(AttributeError):
            setref(c, 999)
Example #6
0
 def simplify(self, positions):
     return symbol(self.token)
Example #7
0
from functools import partial
from sibilant import symbol

import re


__all__ = ( "parse",
            "E_SYMBOL", "E_NUMBER", "E_STRING",
            "E_QUOTE", "E_QUASI", "E_UNQUOTE", "E_SPLICE",
            "E_OPEN", "E_CLOSE", "E_DOT", "E_COMMENT",
            "E_NEWLINE" )


# these are the events that can be emitted.
E_SYMBOL = symbol("E_SYMBOL")
E_NUMBER = symbol("E_NUMBER")
E_STRING = symbol("E_STRING")
E_QUOTE = symbol("E_QUOTE")
E_QUASI = symbol("E_QUASI")
E_UNQUOTE = symbol("E_UNQUOTE")
E_SPLICE = symbol("E_SPLICE")
E_OPEN = symbol("E_OPEN")
E_CLOSE = symbol("E_CLOSE")
E_DOT = symbol("E_DOT")
E_COMMENT = symbol("E_COMMENT")
E_NEWLINE = symbol("E_NEWLINE")


def parse(stream):
    """
Example #8
0
 def test_repr_str(self):
     x = symbol('x')
     self.assertEqual(repr(x), "symbol('x')")
     self.assertEqual(str(x), 'x')