RPython: step7

rpython/Makefile

@@ -14,6 +14,9 @@ step1_read_print: mal_types.py reader.py printer.py
 step2_eval: mal_types.py reader.py printer.py
 step3_env: mal_types.py reader.py printer.py env.py
 step4_if_fn_do: mal_types.py reader.py printer.py env.py core.py
+step5_tco: mal_types.py reader.py printer.py env.py core.py
+step6_file: mal_types.py reader.py printer.py env.py core.py
+step7_quote: mal_types.py reader.py printer.py env.py core.py
 
 clean:
 	rm -f $(STEPS) *.pyc

rpython/core.py

@@ -1,5 +1,4 @@
 import copy, time
-from itertools import chain
 
 import mal_types as types
 from mal_types import (MalType, nil, true, false,
@@ -155,10 +154,18 @@ def count(args):
 
 #def coll_Q(coll): return sequential_Q(coll) or hash_map_Q(coll)
 #
-#def cons(x, seq): return List([x]) + List(seq)
-#
-#def concat(*lsts): return List(chain(*lsts))
-#
+def cons(args):
+    x, seq = args[0], args[1]
+    assert isinstance(seq, MalList)
+    return MalList([x] + seq.values)
+
+def concat(args):
+    new_lst = []
+    for l in args.values:
+        assert isinstance(l, MalList)
+        new_lst = new_lst + l.values
+    return MalList(new_lst)
+
 #def nth(lst, idx):
 #    if idx < len(lst): return lst[idx]
 #    else: throw("nth: index out of range")
@@ -251,8 +258,8 @@ ns = {
 #        'vals': vals,
 #
 #        'sequential?': types._sequential_Q,
-#        'cons': cons,
-#        'concat': concat,
+        'cons': cons,
+        'concat': concat,
 #        'nth': nth,
 #        'first': first,
 #        'rest': rest,

rpython/step7_quote.py

@@ -0,0 +1,169 @@
+import sys, traceback
+import mal_readline
+import mal_types as types
+from mal_types import (MalSym, MalInt, MalStr, nil, true, false,
+                       _symbol, _keywordu, MalList, _list, MalFunc)
+import reader, printer
+from env import Env
+import core
+
+# read
+def READ(str):
+    return reader.read_str(str)
+
+# eval
+def is_pair(x):
+    return types._sequential_Q(x) and len(x) > 0
+
+def quasiquote(ast):
+    if not is_pair(ast):
+        return _list(_symbol(u"quote"), ast)
+    else:
+        a0 = ast[0]
+        if isinstance(a0, MalSym):
+            if a0.value == u'unquote':
+                return ast[1]
+        if is_pair(a0) and isinstance(a0[0], MalSym):
+            a00 = a0[0]
+            if (isinstance(a00, MalSym) and
+                a00.value == u'splice-unquote'):
+                return _list(_symbol(u"concat"),
+                             a0[1],
+                             quasiquote(ast.rest()))
+    return _list(_symbol(u"cons"),
+                quasiquote(a0),
+                quasiquote(ast.rest()))
+
+
+def eval_ast(ast, env):
+    if types._symbol_Q(ast):
+        assert isinstance(ast, MalSym)
+        return env.get(ast)
+    elif types._list_Q(ast):
+        res = []
+        for a in ast.values:
+            res.append(EVAL(a, env))
+        return MalList(res)
+##    elif types._vector_Q(ast):
+##        return types._vector(*map(lambda a: EVAL(a, env), ast))
+##    elif types._hash_map_Q(ast):
+##        keyvals = []
+##        for k in ast.keys():
+##            keyvals.append(EVAL(k, env))
+##            keyvals.append(EVAL(ast[k], env))
+##        return types._hash_map(*keyvals)
+    else:
+        return ast  # primitive value, return unchanged
+
+def EVAL(ast, env):
+    while True:
+        #print("EVAL %s" % printer._pr_str(ast))
+        if not types._list_Q(ast):
+            return eval_ast(ast, env)
+
+        # apply list
+        if len(ast) == 0: return ast
+        a0 = ast[0]
+        if isinstance(a0, MalSym):
+            a0sym = a0.value
+        else:
+            a0sym = u"__<*fn*>__"
+
+        if u"def!" == a0sym:
+            a1, a2 = ast[1], ast[2]
+            res = EVAL(a2, env)
+            return env.set(a1, res)
+        elif u"let*" == a0sym:
+            a1, a2 = ast[1], ast[2]
+            let_env = Env(env)
+            for i in range(0, len(a1), 2):
+                let_env.set(a1[i], EVAL(a1[i+1], let_env))
+            ast = a2
+            env = let_env # Continue loop (TCO)
+        elif u"quote" == a0sym:
+            return ast[1]
+        elif u"quasiquote" == a0sym:
+            ast = quasiquote(ast[1]) # Continue loop (TCO)
+        elif u"do" == a0sym:
+            if len(ast) == 0:
+                return nil
+            elif len(ast) > 1:
+                eval_ast(ast.slice2(1, len(ast)-1), env)
+            ast = ast[-1] # Continue loop (TCO)
+        elif u"if" == a0sym:
+            a1, a2 = ast[1], ast[2]
+            cond = EVAL(a1, env)
+            if cond is nil or cond is false:
+                if len(ast) > 3: ast = ast[3] # Continue loop (TCO)
+                else:            return nil
+            else:
+                ast = a2 # Continue loop (TCO)
+        elif u"fn*" == a0sym:
+            a1, a2 = ast[1], ast[2]
+            return MalFunc(None, a2, env, a1, EVAL)
+        else:
+            el = eval_ast(ast, env)
+            f = el.values[0]
+            if isinstance(f, MalFunc):
+                if f.ast:
+                    ast = f.ast
+                    env = f.gen_env(el.rest()) # Continue loop (TCO) 
+                else:
+                    return f.apply(el.rest())
+            else:
+                raise Exception("%s is not callable" % f)
+
+# print
+def PRINT(exp):
+    return printer._pr_str(exp)
+
+# repl
+class MalEval(MalFunc):
+    def apply(self, args):
+        return self.EvalFunc(args[0], self.env)
+
+def entry_point(argv):
+    repl_env = Env()
+    def REP(str, env):
+        return PRINT(EVAL(READ(str), env))
+
+    # core.py: defined using python
+    for k, v in core.ns.items():
+        repl_env.set(_symbol(unicode(k)), MalFunc(v))
+    repl_env.set(types._symbol(u'eval'),
+                 MalEval(None, env=repl_env, EvalFunc=EVAL))
+    mal_args = []
+    if len(argv) >= 3:
+        for a in argv[2:]: mal_args.append(MalStr(unicode(a)))
+    repl_env.set(_symbol(u'*ARGV*'), MalList(mal_args))
+
+    # core.mal: defined using the language itself
+    REP("(def! not (fn* (a) (if a false true)))", repl_env)
+    REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))", repl_env)
+
+    if len(argv) >= 2:
+        REP('(load-file "' + argv[1] + '")', repl_env)
+        return 0
+
+    while True:
+        try:
+            line = mal_readline.readline("user> ")
+            if line == "": continue
+            print(REP(line, repl_env))
+        except EOFError as e:
+            break
+        except reader.Blank:
+            continue
+        except Exception as e:
+            print(e)
+            #print("".join(traceback.format_exception(*sys.exc_info())))
+    return 0
+
+# _____ Define and setup target ___
+def target(*args):
+    return entry_point
+
+# Just run entry_point if not RPython compilation
+import sys
+if not sys.argv[0].endswith('rpython'):
+    entry_point(sys.argv)