Added __missing metamethod and updated tests.

README.md

@@ -69,6 +69,29 @@ assert(({[t1]='yep'})[Tuple(1,2)])
 assert(tostring(Tuple(1,2)) == "(1, 2)")
 ```
 
+## New Metamethods
+This library adds support for two new metamethods: `__new` and `__missing`. `__new` is called when an instance is created. It takes as arguments the immutable class and all arguments the user passed in, and whatever values it returns are used to create the instance. This is pretty handy for default or derived values.
+```lua
+local Foo = immutable({"x","y","xy"}, {
+    __new = function(cls, x, y)
+        y = y or 3
+        return x, y, x*y
+    end
+})
+assert(Foo(2).xy == 6)
+```
+`__missing` is similar to `__index`, except that it only gets called when accessing a key that is neither one of the immutable class's instance keys, nor one of the keys in the class table.
+```lua
+local Foo = immutable({"x","y"}, {
+    classvar = 23,
+    __missing = function(self, key)
+        return "MISSING"
+    end
+})
+local f = Foo(1, nil)
+assert(f.x == 1 and f.y == nil and f.classvar == 23 and f.asdf == "MISSING")
+```
+
 ## General purpose immutable table recipe
 Using tuples, you can make a function that returns an immutable version of a table with arbitrary keys, though it is a little bit hacky.
 ```lua

limmutable.c

@@ -370,6 +370,16 @@ static int Lindex(lua_State *L)
   class_fallback:
     lua_pushvalue(L, 2);
     lua_gettable(L, 3);
+    if (lua_isnil(L, -1)) {
+        lua_getfield(L, 3, "__missing");
+        if (! lua_isnil(L, -1)) {
+            lua_pushvalue(L, 1);
+            lua_pushvalue(L, 2);
+            lua_call(L, 2, 1);
+            return 1;
+        }
+        return 0;
+    }
     return 1;
 }
 
@@ -623,11 +633,9 @@ static int Lmake_class(lua_State *L)
             // Stack: [CLS, method_name, method_value]
             lua_pushvalue(L, -2);
             // Stack: [CLS, method_name, method_value, method_name]
-            lua_pushvalue(L, -2);
-            // Stack: [CLS, method_name, method_value, method_name, method_value]
-            lua_settable(L, -5);
-            // Stack: [CLS, method_name, method_value]
-            lua_pop(L, 1);
+            lua_insert(L, -2);
+            // Stack: [CLS, method_name, method_name, method_value]
+            lua_settable(L, -4);
             // Stack: [CLS, method_name]
         }
         // Stack: [CLS]

tests.lua

@@ -161,10 +161,22 @@ test("Testing garbage collection", function()
     assert(next(Foo.__instances) == nil)
 end)
 
-test("Testing stupid metamethods", function()
-    local Five = immutable({"x"}, {__index=function() return 5 end, derp = 99})
-    local f = Five(99)
-    assert(f.x == 5 and f.asdf == 5 and f.derp == 5)
+test("Testing __missing", function()
+    local Foo = immutable({"x","y"}, {
+        classvar = 99,
+        __missing=function(self,k) return tostring(k)..tostring(self.x) end
+    })
+    local f = Foo(23, nil)
+    assert(f.x == 23 and f.y == nil and f.classvar == 99 and f.asdf == "asdf23")
+end)
+
+test("Testing __index", function()
+    local Baz = immutable({"x","y"}, {z=99})
+    local b = Baz(1,nil)
+    assert(b.x == 1 and b.y == nil and b.z == 99 and b.asdf == nil)
+    local Foo = immutable({"x","y"}, {z=99, __index=function() return "foo" end})
+    local f = Foo(1,nil)
+    assert(f.x == "foo" and f.y == "foo" and f.z == "foo" and f.asdf == "foo")
 end)
 
 test("Testing similar class", function()
@@ -296,16 +308,6 @@ test("Testing __new with #args", function()
     assert(f.x == 3 and f.y == 4)
 end)
 
-test("Testing __new with #args", function()
-    local Foo = immutable({"x","y"}, {
-        __new=function(cls,x,y,z)
-            return x+z,y+z
-        end
-    })
-    local f = Foo(2,3,1)
-    assert(f.x == 3 and f.y == 4)
-end)
-
 test("Testing __new with varargs", function()
     local Foo = immutable(nil, {
         __new=function(cls,...)