A simple OO-system in Lua

Well, I recently (very recently) started to play around with Lua. I ordered the book before leaving to Colombia and found it when I was back. It took me just a day to read it, as the book is a light read and rather well-written, covering all the important topics.

One reason I’ve started to look at Lua is because it seems like a rather powerful language. Read more if you’re interested in why, and a first OO-system that I’ve rolled in it.

Powerful is a rather abstract word, and perhaps I should first explain why I consider Lua, powerful, especially since I come from a rather different programming language sphere (Haskell).
The reason that lua appeals to me is that it seems to enable a way of meta-programming that cuts cleanly through your code. It takes a scheme-approach of being built-up in an orthogonal manner with a small core. That being said, I find it more appealing than scheme as, at least to me, it is easier to code things in. The meta-programming seems to be more powerful than in scheme.

Anyways, I started coding in it yesterday, wanting to roll an OO-system that would be easy to use. Additionally, I wanted a way to nicely dump my state and then be able to reload it after potentially modifying some of the classes I use.

For the serialization aspect, I took the serialization scheme from the Lua Book and extended it to deal with custom serialization meta-methods as well as the possibilities of keys being tables. Note that it’s not yet finished, it need a small piece of code to generate unique names, but that’s rather trivial.

As for the OO system, this is a second version. My original version was rather primitive. One thing that I wanted was the ability to call the static-super method of a method. Now a simple way would be:

function Class:method(...)
  SuperClass.method(self, ....)
end

I did not like this idea, however, as it requires explicitly referring to the super-class. Certainly, for simple class-trees this is a viable option. However, since I would like to introduce the concept of mixins, and in general don’t like the verbositoy of this, I introduced a ‘static’ way of defining __super (The super-method). Basically, whenever a method is defined, it’s function-environment is modified to have a link to __super (as well as __class). The reason for having a link to __class is that this is the static-class that the method belongs to, not the class of the object.

The (unfinished) code can be seen below. It is based on ideas from: ClassesAndMethodsExample and InheritanceTutorial. As mentioned before, this is only my second day of hacking Lua, so I’m certain there are things that could be done much better. Suggestions, as always, welcome

local setmetatable = setmetatable
--------------------------------------------------------------------------------
-- Helper functions:
--------------------------------------------------------------------------------
function memoize(f)
  local self = setmetatable({}, {__mode = "k"})
  self.__index = function(self, k) local v = f(k); self[k] = v  return v end
  self.__call = function(self, k) return self[k]  end
  return self
end

--------------------------------------------------------------------------------
-- Class System
--------------------------------------------------------------------------------
-- Methods should be called on the klass object with as parameter the object itself!
--
Root = {
  super = nil;
  name  = "Root";
  new   =
    function(class, ...)
      local obj   = {class = class}
      local meta  = {
        __index     = class.methods,
        __serialize = class.__serialize or Root.__serialize
      }
      setmetatable(obj, meta)
      if (class.methods.init) then
        class.methods.init(obj, ...)
      end
      return obj
    end;
   methods = {
     classname   = function(self)
       return (self.class.name)
     end;
     isa         = function(self, aClass)
       local cur_class = self.class
       while (nil ~= cur_class) do
         if cur_class == aClass then
           return true
         else
           cur_class = cur_class.super
         end
       end
       return false
     end
  };
  data    = {};
  __serialize = function(self, serializer, name)
    serializer:write("setmetatable({class = " .. self:classname() .. "}, {\n")
    serializer:write("  __index = " .. self:classname() .. ".methods,\n")
    serializer:write("  __serialize = " .. self:classname() .. ".__serialize or Root.__serialize\n")
    serializer:write("})\n")
    for k,v in pairs(self) do                 -- save its fields
      if k ~= "class" then
        local kname
        if serializer:isBasic(k) then
          kname = serializer:basicSerialize(k)
        elseif type(k) == "table" then
          if saved[k] then
            kname = saved[k]
          else
            kname = serializer:generateName()
            serializer:serialize(kname, k)
          end
        end
        local fname = string.format("%s[%s]", name, kname)
        serializer:serialize(fname, v)
      end
    end
  end
}

function Class(name, super)
  super = super or Root
  class = {
    super = super,
    name  = name,
    methods = {}
  }

  -- if class slot unavailable, check super class
  -- if applied to argument, pass it to the class method new
  setmetatable(class, {
    __index = super,
    __call  = function(self,...) return self:new(...) end
  })

  setmetatable(class.methods, {
    -- if instance method unavailable, check method slot in super class
    __index     = class.super.methods,
    -- when defining a new method, set the environment for proper, static, class access and super-method access
    __newindex  = function (c, m, f)
      if (class.super.methods[m]) then
        setfenv(f, setmetatable({__class = class, __super = class.super.methods[m]}, {__index = getfenv(f) }))
      else
        setfenv(f, setmetatable({__class = class}, {__index = getfenv(f) }))
      end
      rawset(c,m,f)
    end
  })

  return class
end

function Mixin(name, mixin, super)
 --  return (name, nil, super)
end

function Singleton(name, super)
end

--------------------------------------------------------------------------------
-- Serializer
-- TODO: Make a way to easily define what attributes -not- to save
--------------------------------------------------------------------------------
Serializer = Class("Serializer")
function Serializer.methods:init(stream, temp, saved)
  self.stream = stream or io.stdout
  self.temp = temp or 0
  self.saved = saved or {}
end

function Serializer.methods:basicSerialize(value)
  if type(value) == "boolean" then
    return tostring(value)
  elseif type(value) == "number" then
    return tostring(value)
  elseif type(value) == "string" then
    return string.format("%q", value)
  end
end

function Serializer.methods:isBasic(value)
  return type(value) == "boolean" or type(value) == "number" or type(value) == "string"
end

function Serializer.methods:write(...)
  self.stream:write(...)
end

function Serializer.methods:serialize(name, value)
  self:write(name, " = ")
  if self:isBasic(value) then
    self:write(self:basicSerialize(value), "\n")
  elseif type(value) == "table" then
    if self.saved[value] then                 -- value already saved?
      self:write(self.saved[value], "\n")     -- use its previous value
    else
      self.saved[value] = name                -- save name for next time
      serializer = (getmetatable(value) or self).__serialize or self.__serialize
      serializer(value, self, name)
    end
  else
    error("cannot save a " .. type(value))
  end
end

function Serializer.methods:__serialize(serializer, name)
  serializer:write("{}\n")                    -- create a new table
  for k,v in pairs(self) do                   -- save its fields
    local kname
    if serializer:isBasic(k) then
      kname = serializer:basicSerialize(k)
    elseif type(k) == "table" then
      if saved[k] then
        kname = saved[k]
      else
        kname = serializer:generateName()
        serializer:serialize(kname, k)
      end
    end
    local fname = string.format("%s[%s]", name, kname)
    serializer:serialize(fname, v)
  end
end

function deserialize(o, stream)
  stream = stream or io.stdin
end

--------------------------------------------------------------------------------
-- Test Cases
--------------------------------------------------------------------------------
Foo = Class("Foo")
function Foo.methods:init(...)
  self.foo = 1
end

function Foo.methods:__serialize(serializer, name)
  serializer:write("{foo = " .. self.foo .. "}\n")
end

Bar = Class("Bar", Foo)
function Bar.methods:init(...)
  __super(self, ...)
  self.bar = 2
end

function Bar.methods:boom()
  if __super then __super(self) end
  print "Bar:boom"
end

Bum = Class("Bum", Bar)
function Bum.methods:init(...)
  if __super then __super(self, ...) end
  self.bum = 3
end

function Bum.methods:boom()
  if __super then __super(self) end
  print "Bum:boom"
end

Be Sociable, Share!

•