skeleton repl that can eval self-evaling things, quote, and if.

swolchok · swolchok · commit d9ef37a08f35 · 2010-01-05T00:49:00.000-05:00
diff --git a/eval.py b/eval.py
@@ -0,0 +1,73 @@
+# Write this in pseudo-Lark. We have to take a different strategy from
+# Arc because we're not on top of a Lisp or Scheme, so roots comes first instead of in arc.arc.
+from roots import *
+from sexpr import str2sexpr
+from symbol import *
+from types import *
+
+xcar = lambda x: car(x) if acons(x) else None
+
+# Let's not let them poke at raw Python variables without explicitly
+# them.
+
+arc_globals = {nil: nil, ac_global_name(t): t}
+
+# Evaluate an Arc expression, represented as an s-expression.
+# Env is a dictionary of lexically-bound variables (symbol->value).
+def ac_eval(s, env):
+  if isinstance(s, String):
+    return s
+  elif literal(s):
+    return s
+  elif s is nil:
+    return s
+  elif isSymbol(s):
+    return ac_var_ref(s, env)
+  elif xcar(s) == Symbol('quote'):
+    return cadr(s)
+  elif xcar(s) == Symbol('if'):
+    return ac_if(cdr(s), env)
+#  elif xcar(s) == Symbol('fn'):
+#    return ac_fn(cadr(s), cddr(s), env)
+#  elif xcar(s) == Symbol('assign'):
+#    return ac_set(cdr(s), env)
+#  elif acons(s):
+#    return ac_call(car(s), cdr(s), env)
+  else:
+    raise Exception('Bad object in expression %s (type %s)' % (s, type(s)))
+
+
+def literal(x):
+  return isinstance(x, bool) or isinstance(x, int) or isinstance(x, float)
+
+
+def ac_global_name(s):
+  return Symbol('_' + str(s))
+
+
+def ac_var_ref(s, env):
+  if s in env:
+    return env[s]
+  return arc_globals[ac_global_name(s)]
+
+
+# Should False Python objects be false eventually?
+# We're not even close to exposing Python right now, I think.
+def ar_false(x):
+  return x is nil or x == False
+
+def ac_if(s, env):
+  while s is not nil:
+    if cdr(s) is nil:
+      return ac_eval(car(s), env)
+    elif not ar_false(ac_eval(car(s), env)):
+      return ac_eval(cadr(s), env)
+    s = cddr(s)
+
+  return nil
+
+def tle():
+  while True:
+    print 'Lark> ',
+    expr = str2sexpr(raw_input())[0]
+    print ac_eval(expr, {})
diff --git a/roots.py b/roots.py
@@ -1,19 +1,27 @@
 '''Roots of Lisp primitives in Python.
 Let's see how far we can get embedding an Arc-like Lisp in Python.
 '''
+from symbol import *
 
 # We can't use tuples here because we need mutable cons cells.
 # Objects are big and slow.
 cons = lambda x, y: [x,y]
 car = lambda x: x[0]
 cdr = lambda x: x[1]
 
-nil = None
+caar = lambda x: x[0][0]
+cadr = lambda x: x[1][0] # car of cdr.
+cdar = lambda x: x[0][1]
+cddr = lambda x: x[1][1]
+
+pylist = list
+
 # Atom is a problem: we're going to expose Python 2-tuples in our Lisp
 # eventually, and those are probably atoms. Let's just get it working
 # and then we'll worry about the distinction; the associated car/cdr
 # implementations are bad too.
-atom = lambda x: not (isinstance(x, tuple) and len(x) == 2)
+acons = lambda x: isinstance(x, pylist) and len(x) == 2
+atom = lambda x: not acons(x)
 
 # Readable types:
 # - lists
@@ -23,7 +31,7 @@
 
 def _topylist(L):
   acc = []
-  while L is not None:
+  while L is not nil:
     acc.append(car(L))
     L = cdr(L)
   return acc
diff --git a/symbol.py b/symbol.py
@@ -0,0 +1,107 @@
+"""A simple "symbol" class for Python.  Symbols are like strings,
+except that symbols should only be comparable to other symbols.  This
+module is designed so that one should be able to do a "from symbol
+import *" on this.
+
+To create a new Symbol, use the Symbol() function, like this:
+
+    hello = Symbol("hello")
+
+All symbols are interned so that comparison using 'is' will work.  For
+example,
+
+    Symbol("hello") is Symbol("h" + "ello")
+
+should work.
+
+By default, all symbols are case insensitive, but if the module
+variable CASE_SENSITIVE is set to a true value, symbols will become
+case sensitive.
+
+Also, we use the UserString to make sure that symbols are of a
+different "class" than Strings.  isSymbol() depends on this
+representation, so be careful about changing it.
+
+
+Ripped off from PyScheme by Scott Wolchok.
+"""
+
+__license__ = "MIT License"
+
+
+from UserString import UserString as __UserString
+import weakref
+
+__all__ = ['Symbol', 'isSymbol', 'nil', 't']
+
+
+"""By default, symbols are case-insensitive."""
+CASE_SENSITIVE = 0
+
+
+class __Symbol(__UserString):
+    """Support class for symbols."""
+    def __eq__(self, other):
+        """Comparison should only be possible between symbols.  Since all
+        Symbols are interned, this is equivalent to an 'is' check."""
+        return self is other
+
+
+"""A global dictionary that contains all known symbols.
+__interned_symbols: strings -> symbols
+
+The dictionary uses weak references to reduce the chance of symbol abuse.
+"""
+__interned_symbols = weakref.WeakValueDictionary({})
+
+
+def Symbol(s):
+    """Generates a new Symbol that we guarantee can be compared in
+    constant time to any other symbol."""
+    global __interned_symbols
+
+    ## Defensive programming measure:
+    assert not isinstance(s, __Symbol), ("%s already a symbol!" % s)
+
+    if not CASE_SENSITIVE: s = s.lower()
+    if not __interned_symbols.has_key(s):
+        ## Subtle note: we have to use a local variable here to store the newSymbol.
+        ## If we had tried something shorter like:
+        ##
+        ##     __interned_symbol[s] = __Symbol(s)
+        ##
+        ## then the new Symbol will immediately evaporate since there
+        ## aren't any hard references!  Weak references can be tricky.
+        newSymbol = __Symbol(s)
+        __interned_symbols[s] = newSymbol
+    return __interned_symbols[s]
+
+
+
+
+"""Here are definitions of symbols that we should know about."""
+false = Symbol("#f")
+true = Symbol("#t")
+nil = Symbol('nil')
+t = Symbol('t')
+__empty_symbol = Symbol("")
+
+
+def isSymbol(x):
+    """Returns True if x is already a symbol."""
+    return type(x) == type(__empty_symbol)
+
+
+
+def makeUniqueTemporary(_counter = [0]):
+    """Constructs a symbol that does not collide with any other
+    symbol.  I'll use this to help with the macro-expansion.
+
+    NOTE/FIXME: we do this by making an "illegal" symbol which starts
+    with a number and contains a space.  The parser module doesn't
+    allow such symbols to exist... although it's possible to subvert this
+    by calling STRING->SYMBOL.  So this mechanism is not perfect.
+    """
+    while ('%d*** temporary' % _counter[0]) in __interned_symbols:
+        _counter[0] += 1
+    return Symbol('%d*** temporary' % _counter[0])
diff --git a/types.py b/types.py
@@ -0,0 +1,6 @@
+import UserString
+
+__all__ = ['String']
+# XXX: something more efficient, perhaps?
+class String(UserString.MutableString):
+  pass
