Read from ports now

1 files changed, 44 insertions, 58 deletions

@@ -1,114 +1,100 @@
 --- lam.eval
 
-local eval = {}
-local base = require "base"
+local m = {}
+local core = require "core"
 local type = require "type"
-local isNull, isList, isa, List, Cons =
-        type.isNull, type.isList, type.isa, type.List, type.Cons
-local unpack = table.unpack or unpack
 
-function eval.Env (inner, outer)
+function m.environ (inner, outer)
         local mt = {
-                __type = "Environment",
+                __type = "environment",
                 __index = outer,
                 __newindex =
-                        function (self, key, value)
+                        function (self, key, val)
                                 if rawget(self, key) then
-                                        -- Set the current environment's value
-                                        rawset(self, key, value)
+                                        rawset(self, key, val)
                                 else
-                                        -- Set the outer value
-                                        getmetatable(self).__index[key] = value
+                                        getmetatable(self).__index[key] = val
                                 end
                         end,
         }
         return setmetatable(inner, mt)
 end
 
-function eval.Proc (params, body, env)
-        local v = {
+function m.procedure (params, body, env)
+        local t = {
                 params = params,
                 body = body,
                 env = env,
         }
         local mt = {
-                __type = "Procedure",
+                __type = "procedure",
                 __call =
                         function (self, args)
                                 local inner = {}
                                 local p, a = self.params, args
-                                while p.cdr and a.cdr do
-                                        inner[p.car] = a.car
-                                        p, a = p.cdr, a.cdr
+                                while p[2] and a[2] do
+                                        inner[p[1]] = a[1]
+                                        p, a = p[2], a[2]
                                 end
                                 local b = self.body
-                                local e = eval.Env(inner, self.env)
-                                while not isNull(b.cdr) do
-                                        eval.eval(b.car, e)
-                                        b = b.cdr
+                                local e = m.environ(inner, self.env)
+                                while not b[2] == type.null do
+                                        m.eval(b[1], e)
+                                        b = b[2]
                                 end
-                                return eval.eval(b.car, e)
+                                return m.eval(b[1], e)
                         end,
         }
-        return setmetatable(v, mt)
+        return setmetatable(t, mt)
 end
 
 local specials = {
+        -- each of these takes R (a list of args) and E (an environment)
         quote =
-                function (args, env)
-                        return args.car
-                end,
+                function (r, e) return r[1] end,
         define =
-                function (args, env)
-                        rawset(env, args.car, eval(args.cdr.car, env))
-                        return nil
-                end,
+                function (r, e) rawset(e, r[1], m.eval(r[2][1], e)) end,
         lambda =
-                function (args, env)
-                        return Proc(args.car, args.cdr, env)
-                end,
+                function (r, e) return m.procedure(r[1], r[2], e) end,
         ["set!"] =
-                function (args, env)
-                        env[args.car] = eval(args.cdr.car, env)
-                        return nil
-                end,
+                function (r, e) e[r[1]] = m.eval(r[2][1], e) end,
         ["if"] =
-                function (args, env)
+                function (r, e)
                         local test, conseq, alt =
-                                args.car, args.cdr.car, args.cdr.cdr.car
-                        if eval(test)
-                        then return eval(conseq)
-                        else return eval(alt)
+                                r[1], r[2][1], r[2][2][1]
+                        if m.eval(test)
+                        then return m.eval(conseq)
+                        else return m.eval(alt)
                         end
                 end,
-        -- TODO: include, import, define-syntax, define-values(?) ...
+        -- TODO: include, import, define-syntax, ...
 }
 -- Aliases
 specials.lam = specials.lambda
 specials.def = specials.define
 
-function eval.eval (x, env)
-        env = env or base.env
-        if isa(x, "Symbol") then
+function m.eval (x, env)
+        local env = env or core.env
+        if type.isa(x, "symbol") then
                 return env[x]
-        elseif not isList(x) then
+        elseif not type.islist(x) then
                 return x
         else
-                local op, args = x.car, x.cdr
+                local op, args = x[1], x[2]
                 if specials[op] then
                         return specials[op](args, env)
-                else            -- procedure
-                        local proc = eval.eval(op, env)
+                else            -- procedure call
+                        local fn = m.eval(op, env)
                         local params = {}
-                        local a = args
-                        while a.cdr do
-                                table.insert(params, eval.eval(a.car, env))
-                                a = a.cdr
+                        local r = args
+                        while r[2] do
+                                table.insert(params, m.eval(r[1], env))
+                                r = r[2]
                         end
-                        return proc(List(params))
+                        return fn(type.list(params))
                 end
         end
 end
 
----
-return eval
+--------
+return m