Read from ports now

1 files changed, 113 insertions, 89 deletions

@@ -1,138 +1,162 @@
 --- lam.type
--- lisp types
 
-local t = {}
-local util = require "util"
-local unpack = table.unpack or unpack
+local m = {}
+local utf8 = require "utf8"
+utf_char, utf_codepoint = utf8.char, utf8.codepoint
 
---- Determining types
+--- atomic types
 
-t.luatype = type
+-- true, false and nil are just ... true, false, and nil
 
-function t.lamtype (x)
-        if t.luatype(x) == "number" then
-                return "Number"
-        elseif t.luatype(x) == "string" then
-                return "Symbol"
-        elseif getmetatable(x) and getmetatable(x).__type then
-                return getmetatable(x).__type
-        else
-                return t.luatype(x)
-        end
-end
-
--- isa is really only useful on basic types (i.e., not Lists)
-function t.isa (x, type)
-        return t.lamtype(x) == type
+-- Characters contain both their string reputations and their codepoints
+function m.character (x)
+        -- is storing a character with its string and numerical representation
+        -- overkill?  ... maybe.
+        local s = tostring(x)
+        local uc = utf_codepoint(s)
+        local t = { -- String representation of the character
+                v = utf_char(uc),
+                u = uc,
+        }
+        local mt = {
+                __type = "character",
+                __eq = function (self) return self.v end,
+                __lt = function (a, b) return a.u < b.u end,
+                __tostring =
+                        function (self)
+                                local v = self.v
+                                if v == "\n" then
+                                        return "#\\newline"
+                                elseif v == " " then
+                                        return "#\\space"
+                                else
+                                        return "#\\" .. v
+                                end
+                        end,
+        }
+        return setmetatable(t, mt)
 end
 
---- Creating types
-
--- Symbols and Numbers are strings and numbers, respectively.  At some point
--- I'll want to implement a full numeric tower and symbol tables or namespaces
--- or whatever, but today is not that day
+-- a symbol is just a string, unadorned.  I was going to have a character be
+-- represented by a one-character string, but then it would be indistinguishable
+-- from a one-character symbol internally.
+m.symbol = tostring
 
-t.Symbol = tostring
-t.Number = tonumber
+-- for now, number will just be lua's number.  At *some* point, it will be the
+-- whole numeric tower, yaaayyy
+m.number = tonumber
 
--- Strings are (lightly) wrapped
-function t.String (str)
-        local v = {
-                value = str,
+-- strings are wrapped strings
+function m.string (x)
+        local x = tostring(x)
+        local t = {
+                v = x,
                 escape =
                         function (self)
-                                return self.gsub("[\\\"]", "\\%1")
+                                return self.v:gsub("[\\\"]", "\\%1")
                         end,
         }
         local mt = {
-                __type = "String",
+                __type = "string",
                 __tostring =
                         function (self)
-                                return string.format("\"%s\"", self:escape())
+                                return "\"" .. self:escape() .. "\""
                         end,
         }
-        return setmetatable(v, mt)
+        return setmetatable(t, mt)
 end
 
-function t.totable (cons)
-        local out = {}
-        local car, cdr = cons.car, cons.cdr
-        while cdr do
-                table.insert(out, tostring(car))
-                if t.luatype(cdr) == "table" then
-                        car = cdr.car
-                        cdr = cdr.cdr
-                else
-                        table.insert(out, cdr)
-                        break
-                end
-        end
-        return out
-end
+-- null () is both an atom and a list (yay)
+-- this one is NOT a function
+m.null = setmetatable({}, {
+                __type = "null",
+                __tostring = function (self) return "()" end,
+})
+
+--- collection types
 
--- Conses are Lisp's fundamental collection type
-function t.Cons (a, b)
-        local v = { a, b, }
+-- cons are lisp's fundamental collection type
+function m.cons (a, b)
+        local t = { a, b, }
         local mt = {
-                __type = "Cons",
-                __index =
-                        function (self, key)
-                                if key == "car" then
-                                        return self[1]
-                                elseif key == "cdr" then
-                                        return self[2]
-                                end
-                        end,
+                __type = "cons",
                 __tostring =
                         function (self)
                                 local out = {}
-                                local car, cdr = self.car, self.cdr
+                                local car, cdr = self[1], self[2]
                                 while cdr do
                                         table.insert(out, tostring(car))
-                                        if t.luatype(cdr) == "table" then
-                                                car = cdr.car
-                                                cdr = cdr.cdr
+                                        if m.luatype(cdr) == "table" then
+                                                car = cdr[1]
+                                                cdr = cdr[2]
                                         else
                                                 table.insert(out, ".")
                                                 table.insert(out, cdr)
                                                 break
                                         end
                                 end
-                                return "("..table.concat(out, " ")..")"
+                                return "(" .. table.concat(out, " ") .. ")"
                         end,
         }
-        return setmetatable(v, mt)
+        return setmetatable(t, mt)
 end
 
--- Null is the one value that is both an atom and a list
-t.Null = setmetatable({}, {
-                __type = "Null",
-                __tostring = function (self) return "()" end,
-})
+-- lists are singly-linked cons cells
+function m.list (items, last)
+        -- ITEMS is a table and LAST is an optional final cdr.  If it's nil, the
+        -- list is a "proper" list; that is, it ends in ().
+        local function tolist (base, items)
+                if #items == 0 then return base end
+                return tolist(m.cons(table.remove(items), base), items)
+        end
+        return tolist(last or m.null, items)
+end
 
-function t.isNull (x)
-        return x == t.Null
+-- convert a list to a lua table
+function m.totable (cons)
+        local t = {}
+        local car, cdr = cons[1], cons[2]
+        while cdr do
+                table.insert(t, car)
+                if m.luatype(cdr) == "table" then
+                        car = cdr[1]
+                        cdr = cdr[2]
+                else
+                        table.insert(t, cdr)
+                end
+        end
+        return t
 end
 
--- Lists are chained Conses ending in Null
-function t.List (items, last)
-        local function tolist (base, items)
-                if #items == 0 then return base end
-                return tolist(t.Cons(table.remove(items), base), items)
+-- testing types
+
+-- we love name collisions
+m.luatype = type
+
+function m.lamtype (x)
+        if m.luatype(x) == "string" then
+                return "symbol"
+        elseif getmetatable(x) and getmetatable(x).__type then
+                return getmetatable(x).__type
+        else
+                return m.luatype(x)
         end
-        return tolist(last or t.Null, items)
 end
 
-function t.isList (x)
-        -- TODO: this does not detect circular lists yet
-        if t.isNull(x) then
+function m.isa (x, t)
+        return m.lamtype(x) == t
+end
+
+function m.islist (x)
+        -- TODO: detect circular lists
+        if x == m.null then
                 return true
-        elseif t.isa(x, "Cons") then
-                return t.isList(x.cdr)
+        elseif m.isa(x, "cons") then
+                return m.islist(x[2])
         else
                 return false
         end
 end
 
----
-return t
+--------
+return m