uh new start

1 files changed, 70 insertions, 56 deletions

@@ -2,21 +2,20 @@
 
 local eval = {}
 local read = require "read"
+local type = require "type"
 local util = require "util"
-local pp = require "pp"
-local global = require "global"
-local types = require "types"
-table.unpack = table.unpack or unpack
+local unpack = table.unpack or unpack
 
---- Environments and Parameters
--- these aren't in types.lua to avoid a circular dependency
-
-local function Env(inner, outer)
-        return setmetatable(inner, { __type = "Environment", __index = outer, })
+function eval.Env (inner, outer)
+        local mt = {
+                __type = "Environment",
+                __index = outer,
+        }
+        return setmetatable(inner, mt)
 end
 
-local function Proc(params, body, env)
-        local p = {
+function eval.Proc (params, body, env)
+        local v = {
                 params = params,
                 body = body,
                 env = env,
@@ -24,62 +23,77 @@ local function Proc(params, body, env)
         local mt = {
                 __type = "Procedure",
                 __call =
-                        function (self, ...)
+                        function (self, args)
                                 local inner = {}
-                                for _, p in ipairs(self.params) do
-                                        for _, a in ipairs({...}) do
-                                                inner[p] = a
-                                        end
+                                local p, a = self.params, args
+                                while p.cdr and a.cdr do
+                                        inner[p.car] = a.car
+                                        p, a = p.cdr, a.cdr
                                 end
-                                return eval(self.body, Env(inner, self.env))
+                                -- pp.pp(self.body)
+                                return eval.eval(
+                                        self.body,
+                                        eval.Env(inner, self.env))
                         end,
         }
-        return setmetatable(p, mt)
+        return setmetatable(v, mt)
 end
 
-function eval.eval (x, e)
-        e = e or global
-        if types.lamtype(x) == "Symbol" then
-                return e[x]
-        elseif types.luatype(x) ~= "table" then
+local global = {
+        begin =
+                function (args)
+                        local a = args
+                        while not type.isNull(a.cdr) do
+                                a = a.cdr
+                        end
+                        return a.car
+                end,
+        ["+"] =
+                function (args)
+                        local acc = 0
+                        local car, cdr = args.car, args.cdr
+                        while cdr do
+                                acc = acc + car
+                                car, cdr = cdr.car, cdr.cdr
+                        end
+                        return acc
+                end,
+        ["-"] =
+                function (args)
+                        return args.car - args.cdr.car
+                end,
+}
+
+function eval.eval (x, env)
+        env = env or global
+        if type.isa(x, "Symbol") then
+                return env[x]
+        elseif not type.isList(x) then
                 return x
         else
-                local op = util.car(x)
-                local args = util.cdr(x)
-                if op == types.Symbol("quote") then
-                        return args[1]
-                elseif op == types.Symbol("define") then
-                        local sym, exp = table.unpack(args)
-                        e[sym] = eval(exp, e)
-                        --[[
-                                elseif op == "set!" then
-                                local sym, exp = table.unpack(args)
-                                e[sym] = eval(exp, e) --]]
-                elseif op == types.Symbol("lambda") then
-                        local params = util.car(args)
-                        local body = util.cdr(args)
-                        table.insert(body, 1, "begin")
-                        return Proc(params,
-                                    body,
-                                    e)
-                else            -- procedure call
-                        local proc = eval(op, e)
-                        local vals = {}
-                        for k, v in pairs(args) do
-                                vals[k] = eval(v, e)
+                local op, args = x.car, x.cdr
+                if op == "quote" then
+                        return args
+                elseif op == "define" then
+                        env[args.car] = eval.eval(args.cdr.car, env)
+                        return nil
+                elseif op == "lambda" then
+                        return eval.Proc(
+                                args.car,
+                                type.Cons("begin", args.cdr),
+                                env)
+                else            -- procedure
+                        local proc = eval.eval(op, env)
+                        local params = {}
+                        local a = args
+                        while a.cdr do
+                                table.insert(params, eval.eval(a.car, env))
+                                a = a.cdr
                         end
-                        return proc(table.unpack(vals))
+                        return proc(type.List(params))
                 end
         end
 end
 
 ---
-return setmetatable(eval, { __call =
-                                    function(_, x, e)
-                                            local success, result =
-                                                    pcall(eval.eval, x, e)
-                                            if success then return result
-                                            else return ("ERROR: " .. result)
-                                            end
-                                    end
-})
+return eval