Fix weird eval problem

Don't do things ya don't get, kids

3 files changed, 55 insertions, 93 deletions

@@ -2,36 +2,53 @@
 
 local eval = {}
 local read = require "read"
-local types = require "types"
 local util = require "util"
 local pp = require "pp"
 
-Env = types.Object:new {
-        __type = "Environment",
-        __extend =
-                function(self, parms, args, outer)
-                        for _, p in ipairs(parms) do
-                                for _, a in ipairs(args) do
-                                        self[p] = a
-                                end
-                        end
-                        getmetatable(self).__index = outer
-                end,
-}
+local function Type (x)
+        if type(x) == "string" then
+                return "Symbol"
+        elseif type(x) == "number" then
+                return "Number"
+        elseif getmetatable(x) and getmetatable(x).__type then
+                return x.__type
+        elseif type(x) == "table" then
+                return "List"
+        else
+                return type(x)
+        end
+end
 
-Proc = types.Object:new {
-        __type = "Procedure",
-        __call =
-                function (self, args)
-                        local e = Env:new()
-                        e:__extend(self.parms,
-                                   util.table(args),
-                                   self.env)
-                        return eval(self.body[1], e)
-                end
-}
+local Symbol = tostring
+local Number = tonumber
+
+local function Env(inner, outer)
+        return setmetatable(inner, { __type = "Environment", __index = outer, })
+end
+
+local function Proc(params, body, env)
+        local p = {
+                params = params,
+                body = body,
+                env = env,
+        }
+        local mt = {
+                __type = "Procedure",
+                __call =
+                        function (self, ...)
+                                local inner = {}
+                                for _, p in ipairs(self.params) do
+                                        for _, a in ipairs({...}) do
+                                                inner[p] = a
+                                        end
+                                end
+                                return eval(self.body, Env(inner, self.env))
+                        end,
+        }
+        return setmetatable(p, mt)
+end
 
-global_env = Env:new {
+local global_env = {
         -- constants
         ["#t"] = true,
         ["#f"] = false,
@@ -56,11 +73,11 @@ global_env = Env:new {
                 end,
         ["number?"] =
                 function(x)
-                        return types.Type(x) == "Number"
+                        return Type(x) == "Number"
                 end,
         ["symbol?"] =
                 function(x)
-                        return types.Type(x) == "Symbol"
+                        return Type(x) == "Symbol"
                 end,
         -- scheme functions
         ["apply"] =
@@ -95,9 +112,9 @@ end
 
 function eval.eval (x, env)
         env = env or global_env
-        if types.Type(x) == "Symbol" then
+        if Type(x) == "Symbol" then
                 return env[x]
-        elseif types.Type(x) ~= "List" then
+        elseif type(x) ~= "table" then
                 return x
         else
                 local op = util.car(x)
@@ -107,19 +124,15 @@ function eval.eval (x, env)
                 elseif op == "define" then
                         local sym, exp = table.unpack(args)
                         env[sym] = eval(exp, env)
-                elseif op == "set!" then
-                        local sym, exp = table.unpack(args)
-                        env[sym] = eval(exp, env)
+                        --[[
+                                elseif op == "set!" then
+                                local sym, exp = table.unpack(args)
+                                env[sym] = eval(exp, env) --]]
                 elseif op == "lambda" then
-                        local parms = util.car(args)
-                        local body = util.cdr(args)
-                        return Proc:new {
-                                parms = parms,
-                                body = body,
-                                env = env,
-                        }
+                        local params = util.car(args)
+                        local body = util.cdr(args)[1]
+                        return Proc(params, body, env)
                 else            -- procedure call
-                        pp(op)
                         local proc = eval(op, env)
                         local vals = util.map(
                                 function(v) return eval(v, env) end,
@@ -142,4 +155,4 @@ return setmetatable(eval, { __call =
 
 --[[
         (begin (define sq (lambda (x) (* x x))) (define rep (lambda (f) (lambda (x) (f (f x))))))
--- ]]
+        -- ]]
@@ -3,20 +3,6 @@ by C. Duckworth
 
 lam(n.) -- where you go when a scheme goes bad
 
-major work in progress. as of right now ( 2024-02-21 ):
-- (define sq (lambda (x) (* x x)))
-
-(sq 4) ;=> 16
-(sq (sq 4)) ;=> 256
-
-- (define rep (lambda (f) (lambda (x) (f (f x)))))
-
-((rep sq) 4) ;=> ERROR -- trying to call a string value (Symbol, I think, x)
-
-sad face.
-
-however, +, *, all math.* functions and constants, begin, define, work.
-
-apply also works, i'm pretty sure. scheme-style.(was up late last night, think i got that in)
+this is /very much/ a work in progress
 
 contributions/help WELCOME!
@@ -1,37 +0,0 @@
---- lam.types
-
-local types = {}
-
-function types.Type(x)
-        if type(x) == "string" then
-                -- Symbols are Lua strings
-                return "Symbol"
-        elseif type(x) == "number" then
-                -- Numbers are Lua numbers
-                return "Number"
-        elseif x.__type then
-                return x.__type
-        elseif type(x) == "table" then
-                -- Lists are Lua tables (non-adorned)
-                return "List"
-        else
-                return type(x)
-        end
-end
-
-types.Object = { __type = "Object" }
-function types.Object:new(o)
-        o = o or {}
-        setmetatable(o, self)
-        self.__index = self
-        return o
-end
-
---- Boxed types
-
--- Strings
-
--- Lists
-
----
-return types