enough of an evaluator to eval ((fn (a) a) 1)

swolchok · swolchok · commit a6de4f1113b3 · 2010-01-05T02:48:31.000-05:00
diff --git a/eval.py b/eval.py
@@ -1,38 +1,62 @@
 # 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.
+# Arc because we're not on top of a Lisp or Scheme, so roots comes first
+# instead of in arc.arc.
+
+# XXX: ac-dbname and ac-nameit have been elided for now because I'm not sure
+# how to translate them.
+
 from roots import *
 from sexpr import str2sexpr
 from symbol import *
-from types import *
+from larktypes import *
 
 xcar = lambda x: car(x) if acons(x) else None
 
 # Let's not let them poke at raw Python variables without explicitly
-# them.
+# exposing them.
+
+def ac_global_name(s):
+  return Symbol('_' + str(s))
+
 
-arc_globals = {nil: nil, ac_global_name(t): t}
+arc_globals = dict((ac_global_name(sym), value) for sym, value in [
+    (t, t),
+    (Symbol('car'), car)
+    ])
+                   
+
+class InterpretedFunction(object):
+  # Hacky, non-performant function class for interpreter.
+  # When we have a bytecode compiler, life will be better.
+  def __init__(self, TK):
+      pass
 
 # Evaluate an Arc expression, represented as an s-expression.
 # Env is a dictionary of lexically-bound variables (symbol->value).
+# Arc just has a list because Scheme actually keeps track of the variables and
+# values, but in Lark we keep track of them ourselves.
 def ac_eval(s, env):
+  print 'DEBUG: eval %s in %s' % (s, env)
   if isinstance(s, String):
     return s
   elif literal(s):
     return s
   elif s is nil:
     return s
   elif isSymbol(s):
+    print 'DEBUG: var ref'
     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('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)
+  elif acons(s):
+    print 'DEBUG: funcall'
+    return ac_call(car(s), cdr(s), env)
   else:
     raise Exception('Bad object in expression %s (type %s)' % (s, type(s)))
 
@@ -41,11 +65,11 @@ 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):
+  assert isSymbol(s)
+  print 'Referencing %s (type %s) in  with keys' % (s, type(s)),
+  for key in env:
+    print key, type(key)
   if s in env:
     return env[s]
   return arc_globals[ac_global_name(s)]
@@ -66,8 +90,47 @@ def ac_if(s, env):
 
   return nil
 
+def ac_fn(args, body, env):
+  if ac_complex_args(args):
+    raise NotImplementedError()
+  elif body is nil:  # My extension to deal with empty body. No ac-body*.
+    return lambda *args: nil
+  else:
+    env = env.copy() # Not sure if this is necessary. Being paranoid.
+    print 'DEBUG: define function with argslist %s' % args
+    assert isSymbol(xcar(args))
+    def temp(*fargs):
+      env.update(zip(args, fargs))
+      return ac_body(body, env)
+    return temp
+
+
+def ac_body(body, env):
+  if body is nil:
+    return nil
+  return car(revmap(lambda x: ac_eval(x, env), body))
+
+
+def ac_complex_args(args):
+  '''Does a fn arg list use optional params or destructuring?'''
+  if args is nil or isSymbol(args):
+    return False
+  elif acons(args) and isSymbol(car(args)):
+    return ac_complex_args(cdr(args))
+  else:
+    return True
+
+
+def ac_call(fn, args, env):
+  return ac_eval(fn, env)(*topylist(args))
+
+
 def tle():
   while True:
     print 'Lark> ',
     expr = str2sexpr(raw_input())[0]
     print ac_eval(expr, {})
+
+
+if __name__ == '__main__':
+  tle()
diff --git a/roots.py b/roots.py
@@ -29,14 +29,14 @@
 # - numbers as in Python
 # - symbols
 
-def _topylist(L):
+def topylist(L):
   acc = []
   while L is not nil:
     acc.append(car(L))
     L = cdr(L)
   return acc
 
-def _toarclist(L):
+def toarclist(L):
   res = nil
   for x in reversed(L):
     res = cons(x, res)
@@ -47,6 +47,22 @@ def last(x):
     x = cdr(x)
   return x
 
+
+def revappend(x, y):
+#   if x is nil:
+#     return y
+#   return revappend(cdr(x), cons(car(x), y))
+  while x is not nil:
+    x = cdr(x)
+    y = cons(car(x), y)
+  return y
+
+def reverse(x):
+  return revappend(x, nil)
+
+def append(x, y):
+  return revappend(reverse(x), y)
+
 def nconc(x, y):
   if x is nil:
     return y
@@ -59,4 +75,20 @@ def nconc1(x, y):
   return nconc(x, list(y))
 
 def list(*args):
-  return _toarclist(args)
+  return toarclist(args)
+
+def revmap(func, L):
+#   def rec(func, L, acc):
+#     if L is nil:
+#       return acc
+#     return rec(func, cdr(L), cons(func(car(L)), acc))
+#   return rec(func, L, nil)
+  acc = nil
+  while L is not nil:
+    acc = cons(func(car(L)), acc)
+    L = cdr(L)
+  return acc
+
+def map(func, L):
+  # TODO: nreverse.
+  return reverse(revmap(func, L))
