Initial working version.

README.md

@@ -69,8 +69,8 @@ assert(({[t1]='yep'})[Tuple(1,2)])
 assert(tostring(Tuple(1,2)) == "(1, 2)")
 ```
 
-## New Metamethods
+## `__new` Metamethods
-This library adds support for two new user-defined 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.
+This library adds support for a new user-defined metamethods: `__new`. `__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)
@@ -80,26 +80,14 @@ local Foo = immutable({"x","y","xy"}, {
 })
 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")
-```
-If you override `__index` instead of `__missing`, the function you provide will get called for every member access, even valid keys, since immutable table instances are userdatas.
 
-The library also defines a `__hash` metamethod that returns the hash value used internally for instances. Overriding this value does not affect the underlying implementation, but you may find it useful for overriding `__index`:
+The library also defines a `__hash` metamethod that returns the hash value used internally for instances. Overriding this value does not affect the underlying implementation, but you may find it useful for overriding `__index`. This is approximately the behavior of the normal `__index` implementation:
 ```lua
 local Foo = immutable({"x","y"}, {
     classvar = 23,
     __index = function(self, key)
         local cls = getmetatable(self)
-        if cls.__indices[key] != nil then
+        if cls.__indices[key] ~= nil then
             local value = cls.__instances[cls.__hash(self)][self][key]
             return value == nil and "nil inst value" or value
         else
@@ -112,6 +100,19 @@ local f = Foo(1,nil)
 assert(f.x == 1 and f.y == "nil inst value" and f.classvar == 23 and f.asdf == 999)
 ```
 
+All of the normal Lua metamethods are also redundantly stored with a `raw` prefix (e.g. `__rawindex` for `__index`), in case you want to reference them in your implementation of the metamethod:
+```lua
+local 
+local BiggerOnTheInside = immutable(nil, {
+    __len = function(self, key)
+        local cls = getmetatable(self)
+        local len = cls.__rawlen(self)
+        return math.floor(len/2)
+    end
+})
+assert(#BiggerOnTheInside(1,2,3,4,5,6) == 3)
+```
+
 ## 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

@@ -58,36 +58,30 @@ typedef struct {
 
 static int Lcreate_instance(lua_State *L)
 {
-    int n_args = lua_gettop(L)-1;
+    int num_args = lua_gettop(L)-1;
     lua_getfield(L, 1, "__fields");
-    int n = lua_isnil(L, -1) ? -1 : lua_objlen(L, -1);
+    int num_fields = lua_objlen(L, -1);
     lua_pop(L, 1);
     // arg 1: class table, ...
     lua_getfield(L, 1, "__new");
     if (! lua_isnil(L, -1)) {
         // stack: cls, ..., __new
-        lua_insert(L, -n_args-1);
-        // stack: cls, __new, ..., __new
         lua_pushvalue(L, 1);
-        lua_insert(L, -n_args-1);
+        // stack: cls, ..., __new, cls
+        lua_rotate(L, 2, 2);
         // stack: cls, __new, cls, ...
-        lua_call(L, n_args+1, LUA_MULTRET);
+        lua_call(L, num_args+1, LUA_MULTRET);
-        n_args = lua_gettop(L)-1;
+        num_args = lua_gettop(L)-1;
         // stack: cls, ...
     } else {
         lua_pop(L, 1);
     }
-    if (n == -1) {
-        n = n_args;
-    } else if (n_args > n) {
-        luaL_error(L, "Too many args: expected %d, but got %d", n, n_args);
-    }
     
     // Compute the hash:
     unsigned long long ull_hash = 0x9a937c4d; // Seed
-    for (lua_Integer i=1; i <=(lua_Integer)n; i++) {
+    for (lua_Integer i=1; i <=(lua_Integer)num_fields || i <=(lua_Integer)num_args; i++) {
         unsigned long long item_hash;
-        int type = n > n_args ? LUA_TNIL : lua_type(L, 1+i);
+        int type = i > num_args ? LUA_TNIL : lua_type(L, 1+i);
         switch (type) {
             case LUA_TNIL: case LUA_TNONE:
                 // Arbitrarily chosen value
@@ -134,146 +128,280 @@ static int Lcreate_instance(lua_State *L)
 
     lua_getfield(L, 1, "__instances");
 
-    // Stack: [buckets]
+    // Stack: [__instances]
     // Find bucket
     lua_rawgeti(L, -1, hash);
-    // Stack: [buckets, bucket]
+    // Stack: [__instances, bucket]
     if (lua_isnil(L, -1)) {
         // Make a new bucket
-        // Stack: [buckets, nil]
+        // Stack: [__instances, nil]
         lua_pop(L, 1);
-        // Stack: [buckets]
+        // Stack: [__instances]
         lua_createtable(L, 0, 1);
-        // Stack: [buckets, bucket]
+        // Stack: [__instances, bucket]
         lua_pushlightuserdata(L, (void*)&WEAK_KEY_METATABLE);
         lua_gettable(L, LUA_REGISTRYINDEX);
-        // Stack: [buckets, bucket, {__mode='k'}]
+        // Stack: [__instances, bucket, {__mode='k'}]
         lua_setmetatable(L, -2);
-        // Stack: [buckets, bucket]
+        // Stack: [__instances, bucket]
         lua_pushvalue(L, -1);
-        // Stack: [buckets, bucket, bucket]
+        // Stack: [__instances, bucket, bucket]
         lua_rawseti(L, -3, hash);
-        // Stack: [buckets, bucket]
+        // Stack: [__instances, bucket]
     } else {
-        // Stack: [buckets, bucket]
+        // Stack: [__instances, bucket]
         // scan bucket
         lua_pushnil(L);
         while (lua_next(L, -2) != 0) { // for hash_collider_inst, hash_collider in pairs(bucket) do
-            // Stack: [buckets, bucket, hash_collider_inst, hash_collider]
+            // Stack: [__instances, bucket, hash_collider_inst, hash_collider]
             // Shallow equality check:
             lua_pushnil(L);
             while (lua_next(L, -2) != 0) { // for i, collider_value in pairs(hash_collider) do
-                // Stack: [buckets, bucket, hash_collider_inst, hash_collider, i, value]
+                // Stack: [__instances, bucket, hash_collider_inst, hash_collider, i, value]
                 if (!lua_rawequal(L, -1, 1+lua_tonumber(L, -2))) { // If the i'th entry doesn't match the i'th arg
-                    // Stack: [buckets, bucket, hash_collider_inst, hash_collider, i, value]
+                    // Stack: [__instances, bucket, hash_collider_inst, hash_collider, i, value]
                     lua_pop(L, 3);
-                    // Stack: [buckets, bucket, hash_collider_inst]
+                    // Stack: [__instances, bucket, hash_collider_inst]
                     goto next_bucket_item;
                 } else {
-                    // Stack: [buckets, bucket, hash_collider_inst, hash_collider, i, value]
+                    // Stack: [__instances, bucket, hash_collider_inst, hash_collider, i, value]
                     lua_pop(L, 1);
-                    // Stack: [buckets, bucket, hash_collider_inst, hash_collider, i]
+                    // Stack: [__instances, bucket, hash_collider_inst, hash_collider, i]
                 }
             }
             // bucket item matches
-            // Stack: [buckets, bucket, hash_collider_inst, hash_collider]
+            // Stack: [__instances, bucket, hash_collider_inst, hash_collider]
             lua_pop(L, 1);
             return 1;
 
             next_bucket_item: ;
         }
     }
+    lua_insert(L, -2);
+    // Stack: [bucket, __instances]
+    lua_pop(L, 1);
+    // Stack: [bucket]
+    int bucket_index = lua_gettop(L);
 
     // Failed to find an existing instance, so create a new one
-    // Stack: [buckets, bucket]
+    // Stack: [bucket]
     immutable_info_t *userdata = (immutable_info_t*)lua_newuserdata(L, sizeof(immutable_info_t));
+    // Stack [bucket, inst_userdata]
+    int userdata_index = lua_gettop(L);
     userdata->hash = hash;
-    userdata->len = n;
+    userdata->len = num_fields > num_args ? num_fields : num_args;
     
-    // Stack [buckets, bucket, inst_userdata]
     lua_pushvalue(L, 1);
-    // Stack [buckets, bucket, inst_userdata, metatable]
+    // Stack [bucket, inst_userdata, cls]
     lua_setmetatable(L, -2);
-    // Stack [buckets, bucket, inst_userdata]
+    // Stack [bucket, inst_userdata]
-    lua_pushvalue(L, -1);
+    lua_createtable(L, userdata->len, 0); // Create the table to store the instance's data
-    // Stack [buckets, bucket, inst_userdata, inst_userdata]
+    // Stack [bucket, inst_userdata, inst_table]
-    lua_createtable(L, n, 1); // Create the table to store the instance's data
+    for (lua_Integer i=1; i <= (lua_Integer)num_args; i++) {
-    // Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table]
+        lua_pushvalue(L, i+1);
+        // Stack [bucket, inst_userdata, inst_table, arg #1+i]
+        lua_rawseti(L, -2, i);
+    }
 
     // Set up a ref to the bucket so its lifetime is tied to inst_userdata
     lua_getfield(L, 1, "__buckets");
-    // Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, __buckets]
+    // Stack [bucket, inst_userdata, inst_table, __buckets]
-    lua_pushvalue(L, -3);
+    lua_pushvalue(L, userdata_index);
-    // Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, __buckets, inst_userdata]
+    // Stack [bucket, inst_userdata, inst_table, __buckets, inst_userdata]
-    lua_pushvalue(L, -6);
+    lua_pushvalue(L, bucket_index);
-    // Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, __buckets, inst_userdata, bucket]
+    // Stack [bucket, inst_userdata, inst_table, __buckets, inst_userdata, bucket]
     lua_settable(L, -3);
     lua_pop(L, 1);
     
-    // Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table]
+    // Stack [bucket, inst_userdata, inst_table]
-    lua_Integer i;
+    lua_pushvalue(L, userdata_index);
-    for (i=1; i <= (lua_Integer)n_args; i++) {
+    // Stack [bucket, inst_userdata, inst_table, inst_userdata]
-        lua_pushvalue(L, i+1);
+    lua_rotate(L, bucket_index, 1);
-        // Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, arg #1+i]
+    // Stack [inst_userdata, bucket, inst_userdata, inst_table]
-        lua_rawseti(L, -2, i);
+    lua_settable(L, -3); // buckets[inst_userdata] = inst_table
-    }
+    lua_pop(L, 1);
-    for (; i <= (lua_Integer)n; i++) {
+    // Stack [inst_userdata]
-        lua_pushnil(L);
-        // Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table, nil]
-        lua_rawseti(L, -2, i);
-    }
-    // Stack [buckets, bucket, inst_userdata, inst_userdata, inst_table]
-    lua_settable(L, -4); // buckets[inst_userdata] = inst_table
-    // Stack [buckets, bucket, inst_userdata]
     lua_gc(L, LUA_GCSTEP, 3);
     return 1;
 }
 
 static int Lfrom_table(lua_State *L)
 {
-    lua_pushvalue(L, 1);
+    lua_getfield(L, 1, "__fields");
-    // Stack: [mt]
+    int fields_index = lua_gettop(L);
-    lua_getfield(L, -1, "__fields");
+    int num_fields = lua_objlen(L, -1);
-    int n;
+    int num_values = num_fields + lua_objlen(L, 2);
-    if (lua_isnil(L, -1)) {
+    
-        lua_pop(L, 1);
+    // Compute the hash:
-        lua_getfield(L, 2, "n");
+    unsigned long long ull_hash = 0x9a937c4d; // Seed
-        if (lua_isnil(L, -1)) {
+    for (lua_Integer i=1; i <=(lua_Integer)num_values; i++) {
-            n = lua_objlen(L, 2);
+        unsigned long long item_hash;
-        } else {
+        // Stack: [fields]
-            n = luaL_checkinteger(L, -1);
+        if (i <= num_fields) {
-        }
+            lua_rawgeti(L, fields_index, i);
-        lua_pop(L, 1);
+            // Stack: [fields, fields[i]]
-        if (! lua_checkstack(L, n)) {
-            luaL_error(L, "Insufficient stack space!");
-        }
-        for (int i = 1; i <= n; i++) {
-            lua_rawgeti(L, 2, i);
-        }
-        // Stack: [mt, table[1], table[2], ... table[table.n]]
-    } else {
-        n = lua_objlen(L, -1);
-        if (! lua_checkstack(L, n)) {
-            luaL_error(L, "Insufficient stack space!");
-        }
-        // Stack: [mt, fields]
-        lua_pushnil(L);
-        while (lua_next(L, -2) != 0) {
-            // Stack: [mt, fields, i, field_i]
             lua_gettable(L, 2);
-            // Stack: [mt, fields, i, table[field_i]]
+            // Stack: [fields, table[fields[i]]]
-            lua_insert(L, -3);
+        } else {
-            // Stack: [mt, table[field_i], fields, i]
+            lua_rawgeti(L, 2, i - num_fields);
+            // Stack: [fields, table[i-num_fields]]
         }
-        // Stack: [mt, table[field], ..., fields]
+        // Stack: [fields, value[i]]
+        int type = lua_type(L, -1);
+        switch (type) {
+            case LUA_TNIL: case LUA_TNONE:
+                // Arbitrarily chosen value
+                item_hash = 0x97167da9;
+                break;
+            case LUA_TNUMBER:
+                {
+                    // Cast float bits to integer
+                    lua_Number num = lua_tonumber(L, -1);
+                    item_hash = *((lua_Integer*)&num);
+                    if (item_hash == 0) {
+                        item_hash = 0x2887c992;
+                    }
+                    break;
+                }
+            case LUA_TBOOLEAN:
+                // Arbitrarily chosen values
+                item_hash = lua_toboolean(L, -1)? 0x82684f71 : 0x88d66f2a;
+                break;
+            case LUA_TTABLE:
+            case LUA_TFUNCTION:
+            case LUA_TUSERDATA:
+            case LUA_TTHREAD:
+            case LUA_TLIGHTUSERDATA:
+                item_hash = (1000003 * type) ^ (lua_Integer)lua_topointer(L, -1);
+                break;
+            case LUA_TSTRING:
+                {
+                    // Algorithm taken from Lua 5.3's implementation
+                    size_t len;
+                    const char *str = lua_tolstring(L, -1, &len);
+                    item_hash = len ^ 0xd2e9e9ac; // Arbitrary seed
+                    size_t step = (len >> LUAI_HASHLIMIT) + 1;
+                    for (; len >= step; len -= step)
+                        item_hash ^= ((item_hash<<5) + (item_hash>>2) + (unsigned char)(str[len - 1]));
+                    break;
+                }
+            default:
+                item_hash = 0;
+        }
+        ull_hash = (1000003 * ull_hash) ^ item_hash;
         lua_pop(L, 1);
-        // Stack: [mt, table[field], ...]
+        // Stack: [fields]
     }
-    lua_pushcfunction(L, Lcreate_instance);
+    int hash = (int)ull_hash;
-    // Stack: [mt, table[field], ..., create]
+
-    lua_insert(L, -(n+2));
+    lua_getfield(L, 1, "__instances");
-    // Stack: [create, mt, table[field_1], ...]
+
-    lua_call(L, n+1, 1);
+    // Stack: [fields, __instances]
+    // Find bucket
+    lua_rawgeti(L, -1, hash);
+    // Stack: [fields, __instances, bucket]
+    if (lua_isnil(L, -1)) {
+        // Make a new bucket
+        // Stack: [fields, __instances, nil]
+        lua_pop(L, 1);
+        // Stack: [fields, __instances]
+        lua_createtable(L, 0, 1);
+        // Stack: [fields, __instances, bucket]
+        lua_pushlightuserdata(L, (void*)&WEAK_KEY_METATABLE);
+        lua_gettable(L, LUA_REGISTRYINDEX);
+        // Stack: [fields, __instances, bucket, {__mode='k'}]
+        lua_setmetatable(L, -2);
+        // Stack: [fields, __instances, bucket]
+        lua_pushvalue(L, -1);
+        // Stack: [fields, __instances, bucket, bucket]
+        lua_rawseti(L, -3, hash);
+        // Stack: [fields, __instances, bucket]
+    } else {
+        // Stack: [fields, __instances, bucket]
+        // scan bucket
+        lua_pushnil(L);
+        while (lua_next(L, -2) != 0) { // for hash_collider_inst, hash_collider in pairs(bucket) do
+            // Stack: [fields, __instances, bucket, hash_collider_inst, hash_collider]
+            // Shallow equality check:
+            lua_pushnil(L);
+            while (lua_next(L, -2) != 0) { // for i, collider_value in pairs(hash_collider) do
+                // Stack: [fields, __instances, bucket, hash_collider_inst, hash_collider, i, value]
+                int i = lua_tonumber(L, -2);
+                if (i <= num_fields) {
+                    lua_rawgeti(L, fields_index, i);
+                    lua_gettable(L, 2);
+                } else {
+                    lua_rawgeti(L, 2, i-num_fields);
+                }
+                // Stack: [fields, __instances, bucket, hash_collider_inst, hash_collider, i, value, table_value]
+                if (!lua_rawequal(L, -1, -2)) { // If the i'th entry doesn't match the i'th arg
+                    // Stack: [fields, __instances, bucket, hash_collider_inst, hash_collider, i, value, table_value]
+                    lua_pop(L, 4);
+                    // Stack: [fields, __instances, bucket, hash_collider_inst]
+                    goto next_bucket_item;
+                } else {
+                    // Stack: [fields, __instances, bucket, hash_collider_inst, hash_collider, i, value, table_value]
+                    lua_pop(L, 2);
+                    // Stack: [fields, __instances, bucket, hash_collider_inst, hash_collider, i]
+                }
+            }
+            // bucket item matches
+            // Stack: [fields, __instances, bucket, hash_collider_inst, hash_collider]
+            lua_pop(L, 1);
+            return 1;
+
+            next_bucket_item: ;
+        }
+    }
+    lua_insert(L, -2);
+    // Stack: [fields, bucket, __instances]
+    lua_pop(L, 1);
+    // Stack: [fields, bucket]
+    int bucket_index = lua_gettop(L);
+
+    // Failed to find an existing instance, so create a new one
+    // Stack: [fields, bucket]
+    immutable_info_t *userdata = (immutable_info_t*)lua_newuserdata(L, sizeof(immutable_info_t));
+    // Stack [fields, bucket, inst_userdata]
+    int userdata_index = lua_gettop(L);
+    userdata->hash = hash;
+    userdata->len = num_values;
+    
+    lua_pushvalue(L, 1);
+    // Stack [fields, bucket, inst_userdata, cls]
+    lua_setmetatable(L, -2);
+    // Stack [fields, bucket, inst_userdata]
+    lua_createtable(L, userdata->len, 0); // Create the table to store the instance's data
+    // Stack [fields, bucket, inst_userdata, inst_table]
+    for (lua_Integer i=1; i <= (lua_Integer)num_fields; i++) {
+        lua_rawgeti(L, fields_index, i);
+        lua_gettable(L, 2);
+        lua_rawseti(L, -2, i);
+    }
+    for (lua_Integer i=num_fields+1; i <= num_values; i++) {
+        lua_rawgeti(L, 2, i-num_fields);
+        lua_rawseti(L, -2, i);
+    }
+
+    // Set up a ref to the bucket so its lifetime is tied to inst_userdata
+    lua_getfield(L, 1, "__buckets");
+    // Stack [fields, bucket, inst_userdata, inst_table, __buckets]
+    lua_pushvalue(L, userdata_index);
+    // Stack [fields, bucket, inst_userdata, inst_table, __buckets, inst_userdata]
+    lua_pushvalue(L, bucket_index);
+    // Stack [fields, bucket, inst_userdata, inst_table, __buckets, inst_userdata, bucket]
+    lua_settable(L, -3);
+    lua_pop(L, 1);
+    
+    // Stack [fields, bucket, inst_userdata, inst_table]
+    lua_pushvalue(L, userdata_index);
+    // Stack [fields, bucket, inst_userdata, inst_table, inst_userdata]
+    lua_rotate(L, bucket_index, 1);
+    // Stack [fields, inst_userdata, bucket, inst_userdata, inst_table]
+    lua_settable(L, -3); // buckets[inst_userdata] = inst_table
+    lua_pop(L, 1);
+    // Stack [fields, inst_userdata]
+    lua_gc(L, LUA_GCSTEP, 3);
     return 1;
 }
 
@@ -291,97 +419,93 @@ static int Lis_instance(lua_State *L)
 static int Llen(lua_State *L)
 {
     luaL_checktype(L, 1, LUA_TUSERDATA);
+    if (! lua_getmetatable(L, 1)) {
+        luaL_error(L, "invalid type");
+    }
     immutable_info_t *info = (immutable_info_t *)lua_touserdata(L, 1);
-    lua_pushinteger(L, info->len);
+    lua_getfield(L, -1, "__fields");
+    size_t len = info->len - lua_objlen(L, -1);
+    lua_pushinteger(L, len);
     return 1;
 }
 
-static int Lindex(lua_State *L)
+static int Linst_index(lua_State *L)
 {
+    // Return inst[key], <whether inst has key>
     luaL_checktype(L, 1, LUA_TUSERDATA);
     if (! lua_getmetatable(L, 1)) {
         luaL_error(L, "invalid type");
     }
+    // Stack: [mt]
     immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
     if (! info) {
         luaL_error(L, "invalid type");
     }
 
+    lua_getfield(L, -1, "__fields");
+    size_t num_fields = lua_objlen(L, -1);
+    lua_pop(L, 1);
+
     // Stack: [mt]
     lua_getfield(L, -1, "__indices");
     // Stack: [mt, indices]
+    lua_pushvalue(L, 2);
+    lua_gettable(L, -2);
+    // Stack: [mt, indices, index]
+    int index;
     if (lua_isnil(L, -1)) {
         if (! lua_isinteger(L, 2)) {
-            goto class_fallback;
+            return 0;
         }
-        lua_pop(L, 1);
+        index = lua_tointeger(L, 2) + num_fields;
-        // Stack: [mt]
+    } else {
-        lua_getfield(L, -1, "__instances");
+        index = lua_tointeger(L, -1);
-        // Stack: [mt, buckets]
+    }
-        lua_rawgeti(L, -1, info->hash);
+    lua_pop(L, 2);
-        // Stack: [mt, buckets, bucket]
+    // Stack: [mt]
-        if (lua_isnil(L, -1)) {
+    if (! (0 < index && index <= (int)info->len)) {
-            luaL_error(L, "Failed to find hash bucket");
+        return 0;
-        }
+    }
-        lua_pushvalue(L, 1);
+    // Stack: [mt]
-        // Stack: [mt, buckets, bucket, inst_udata]
+    lua_getfield(L, -1, "__instances");
-        lua_rawget(L, -2);
+    // Stack: [mt, buckets]
-        // Stack: [mt, buckets, bucket, inst_table]
+    lua_rawgeti(L, -1, info->hash);
-        int i = luaL_checkinteger(L, 2);
+    // Stack: [mt, buckets, bucket]
-        lua_rawgeti(L, -1, i);
+    if (lua_isnil(L, -1)) {
-        if (lua_isnil(L, -1)) {
+        luaL_error(L, "Failed to find hash bucket");
-            goto class_fallback;
+    }
+    lua_pushvalue(L, 1);
+    // Stack: [mt, buckets, bucket, inst_udata]
+    lua_rawget(L, -2);
+    // Stack: [mt, buckets, bucket, inst_table]
+    if (lua_isnil(L, -1)) {
+        luaL_error(L, "Failed to find instance");
+    }
+    lua_rawgeti(L, -1, index);
+    lua_pushboolean(L, 1);
+    return 2;
+}
+
+static int Lindex(lua_State *L)
+{
+    int ret = Linst_index(L);
+    if (ret > 0) {
+        if (ret > 1) {
+            lua_pop(L, ret-1);
         }
         return 1;
     }
-
-    // Stack: [mt, indices]
-    lua_pushvalue(L, 2);
-    // Stack: [mt, indices, k]
-    lua_gettable(L, -2);
-    // Stack: [mt, indices, i]
-    if (lua_isnil(L, -1) && lua_isinteger(L, 2)) {
-        int i = lua_tointeger(L, 2);
-        if (1 <= i && i <= (int)info->len) {
-            // Use the raw value of i
-            lua_pop(L, 1);
-            lua_pushvalue(L, 2);
-        }
-    }
-    if (lua_isnil(L, -1)) { // Didn't find the field name
-        goto class_fallback;
-    }
-    // Stack: [mt, indices, i]
-    lua_getfield(L, -3, "__instances");
-    // Stack: [mt, indices, i, buckets]
-    lua_rawgeti(L, -1, info->hash);
-    // Stack: [mt, indices, i, buckets, bucket]
-    if (lua_isnil(L, -1)) {
-        luaL_error(L, "Failed to find hash bucket for hash: %d", info->hash);
-    }
-    lua_pushvalue(L, 1);
-    // Stack: [mt, indices, i, buckets, bucket, inst_udata]
-    lua_rawget(L, -2);
-    // Stack: [mt, indices, i, buckets, bucket, inst_table]
-    int i = luaL_checkinteger(L, -4);
-    lua_rawgeti(L, -1, i);
-    return 1;
-
     // Fall back to class:
-  class_fallback:
+    lua_getmetatable(L, 1);
+    // Stack: [..., mt]
     lua_pushvalue(L, 2);
-    lua_gettable(L, 3);
+    // Stack: [..., mt, key]
-    if (lua_isnil(L, -1)) {
+    lua_gettable(L, -2);
-        lua_getfield(L, 3, "__missing");
+    // Stack: [..., mt, value]
-        if (! lua_isnil(L, -1)) {
+    if (! lua_isnil(L, -1)) {
-            lua_pushvalue(L, 1);
+        return 1;
-            lua_pushvalue(L, 2);
-            lua_call(L, 2, 1);
-            return 1;
-        }
-        return 0;
     }
-    return 1;
+    return 0;
 }
 
 static int Ltostring(lua_State *L)
@@ -392,9 +516,10 @@ static int Ltostring(lua_State *L)
     if (! lua_getmetatable(L, 1)) {
         luaL_error(L, "invalid type");
     }
+    int cls_index = lua_gettop(L);
     // Stack: [mt]
     
-    lua_getfield(L, -1, "name");
+    lua_getfield(L, cls_index, "name");
     if (!lua_isnil(L, -1)) {
         luaL_addvalue(&b);
     } else {
@@ -402,7 +527,7 @@ static int Ltostring(lua_State *L)
     }
     luaL_addstring(&b, "(");
     
-    lua_getfield(L, -1, "__instances");
+    lua_getfield(L, cls_index, "__instances");
     // Stack: [mt, buckets]
     immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
     if (! info) {
@@ -416,66 +541,37 @@ static int Ltostring(lua_State *L)
     lua_pushvalue(L, 1);
     // Stack: [mt, buckets, bucket, inst_udata]
     lua_rawget(L, -2);
+    if (lua_isnil(L, -1)) {
+        luaL_error(L, "Failed to find instance table");
+    }
     int inst_table_index = lua_gettop(L);
     // Stack: [mt, buckets, bucket, inst_table]
     lua_getglobal(L, "tostring");
-    // Stack: [mt, buckets, bucket, inst_table, tostring]
     int tostring_index = lua_gettop(L);
-    lua_getfield(L, -5, "__fields");
+    // Stack: [mt, buckets, bucket, inst_table, tostring]
-    // Stack: [mt, buckets, bucket, inst_table, tostring, fields]
+    int n = info->len, i = 1;
-    if (lua_isnil(L, -1)) {
+    if (i <= n) {
-        lua_pop(L, 1);
-        // Stack: [mt, buckets, bucket, inst_table, tostring]
-        immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
-        int n = info->len, i = 1;
         goto first_list_item;
-        while (++i <= n) {
+    }
-            // Stack: [mt, buckets, bucket, inst_table, tostring, ???]
+    while (++i <= n) {
-            luaL_addstring(&b, ", ");
+        // Stack: [mt, buckets, bucket, inst_table, tostring, ???]
-          first_list_item:
+        luaL_addstring(&b, ", ");
-            lua_pushvalue(L, tostring_index);
+      first_list_item:
-            // Stack: [mt, buckets, bucket, inst_table, tostring, ???, tostring]
+        lua_pushvalue(L, tostring_index);
-            lua_rawgeti(L, inst_table_index, i);
+        // Stack: [mt, buckets, bucket, inst_table, tostring, ???, tostring]
-            // Stack: [mt, buckets, bucket, inst_table, tostring, ???, tostring, value]
+        lua_rawgeti(L, inst_table_index, i);
-            int quotes = lua_type(L, -1) == LUA_TSTRING;
+        // Stack: [mt, buckets, bucket, inst_table, tostring, ???, tostring, value]
-            lua_call(L, 1, 1);
+        int quotes = lua_type(L, -1) == LUA_TSTRING;
-            if (quotes) {
+        lua_call(L, 1, 1);
-                luaL_addchar(&b, '"');
+        if (quotes) {
-            }
+            luaL_addchar(&b, '"');
-            // Stack: [mt, buckets, bucket, inst_table, tostring, ???, value string]
-            luaL_addvalue(&b);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, ???]
-            if (quotes) {
-                luaL_addchar(&b, '"');
-            }
         }
-    } else {
+        // Stack: [mt, buckets, bucket, inst_table, tostring, ???, value string]
-        int fields_index = lua_gettop(L);
+        // TODO: properly escape strings? str:gsub('["\\]',"\\%1"):gsub("\n","\\n")
-        int i = 1, num_fields = lua_objlen(L, -1);
+        luaL_addvalue(&b);
-        goto first_table_item;
+        // Stack: [mt, buckets, bucket, inst_table, tostring, ???]
-        while (++i <= num_fields) {
+        if (quotes) {
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???]
+            luaL_addchar(&b, '"');
-            luaL_addstring(&b, ", ");
-          first_table_item:
-            lua_pushvalue(L, tostring_index);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, tostring]
-            lua_rawgeti(L, fields_index, i);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, tostring, fieldname]
-            lua_call(L, 1, 1);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, field string]
-            luaL_addvalue(&b);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???]
-            
-            luaL_addstring(&b, "=");
-
-            lua_pushvalue(L, tostring_index);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, tostring]
-            lua_rawgeti(L, inst_table_index, i);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, tostring, value]
-            lua_call(L, 1, 1);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???, value string]
-            luaL_addvalue(&b);
-            // Stack: [mt, buckets, bucket, inst_table, tostring, fields, ???]
         }
     }
     luaL_addstring(&b, ")");
@@ -509,6 +605,11 @@ static int Lnexti(lua_State *L)
     lua_rawget(L, -2);
     // Stack: [mt, buckets, bucket, inst_table]
     lua_pushinteger(L, i);
+    // Stack: [mt, buckets, bucket, inst_table, i]
+    lua_getfield(L, -5, "__fields");
+    // Stack: [mt, buckets, bucket, inst_table, i, __fields]
+    i += lua_objlen(L, -1);
+    lua_pop(L, 1);
     lua_rawgeti(L, -2, i);
     // Stack: [mt, buckets, bucket, inst_table, i, table[i]]
     return 2;
@@ -530,47 +631,58 @@ static int Lnext(lua_State *L)
     if (! lua_getmetatable(L, 1)) {
         luaL_error(L, "invalid type");
     }
+    int cls_index = lua_gettop(L);
     // Stack: [mt]
-    lua_getfield(L, -1, "__instances");
+    lua_getfield(L, cls_index, "__fields");
-    // Stack: [mt, buckets]
+    int fields_index = lua_gettop(L);
+    lua_getfield(L, cls_index, "__indices");
+    int indices_index = lua_gettop(L);
+    lua_getfield(L, cls_index, "__instances");
+    // Stack: [..., buckets]
     immutable_info_t *info = (immutable_info_t*)lua_touserdata(L, 1);
     if (! info) {
         luaL_error(L, "invalid type");
     }
     lua_rawgeti(L, -1, info->hash);
-    // Stack: [mt, buckets, bucket]
+    // Stack: [..., buckets, bucket]
     if (lua_isnil(L, -1)) {
         luaL_error(L, "Failed to find hash bucket");
     }
     lua_pushvalue(L, 1);
-    // Stack: [mt, buckets, bucket, inst_udata]
+    // Stack: [..., buckets, bucket, inst_udata]
     lua_rawget(L, -2);
-    // Stack: [mt, buckets, bucket, inst_table]
+    // Stack: [..., buckets, bucket, inst_table]
-    lua_getfield(L, -4, "__indices");
+    size_t num_fields = lua_objlen(L, fields_index);
-    // Stack: [mt, buckets, bucket, inst_table, fields]
+    int index;
-    if (lua_isnil(L, -1)) {
+    if (lua_isnil(L, 2)) {
-        lua_pop(L, 1);
+        index = 1;
-        // Stack: [mt, buckets, bucket, inst_table]
-        int i = lua_isnil(L, 2) ? 1 : lua_tointeger(L, 2)+1;
-        if (i > (int)info->len) {
-            return 0;
-        }
-        lua_pushinteger(L, i);
-        // Stack: [mt, buckets, bucket, inst_table, k]
-        lua_rawgeti(L, -2, i);
-        // Stack: [mt, buckets, bucket, inst_table, k, value]
-        return 2;
     } else {
         lua_pushvalue(L, 2);
-        // Stack: [mt, buckets, bucket, inst_table, fields, k]
+        // Stack: [..., buckets, bucket, inst_table, k]
-        if (lua_next(L, -2) == 0) {
+        lua_gettable(L, indices_index);
-            return 0;
+        // Stack: [..., buckets, bucket, inst_table, i]
+        if (! lua_isnil(L, -1)) {
+            index = lua_tointeger(L, -1) + 1;
+        } else {
+            index = lua_tointeger(L, 2) + num_fields + 1;
         }
-        // Stack: [mt, buckets, bucket, inst_table, fields, k2, next_i]
+        lua_pop(L, 1);
-        lua_gettable(L, -4);
-        // Stack: [mt, buckets, bucket, inst_table, fields, k2, value]
-        return 2;
     }
+    // Stack: [..., buckets, bucket, inst_table]
+    if (! (0 < index && index <= (int)info->len)) {
+        return 0;
+    }
+
+    // Now find field name
+    if (index <= (int)num_fields) {
+        lua_rawgeti(L, fields_index, index);
+    } else {
+        lua_pushinteger(L, index - num_fields);
+    }
+    // Stack: [..., buckets, bucket, inst_table, k2]
+    lua_rawgeti(L, -2, index);
+    // Stack: [..., buckets, bucket, inst_table, k2, value2]
+    return 2;
 }
 
 static int Lpairs(lua_State *L)
@@ -584,25 +696,6 @@ static int Lpairs(lua_State *L)
     return 3;
 }
 
-static int Ltable(lua_State *L)
-{
-    lua_getmetatable(L, 1);
-    // Stack: [mt]
-    lua_getfield(L, -1, "__instances");
-    // Stack: [mt, buckets]
-    immutable_info_t *info = (immutable_info_t *)lua_touserdata(L, 1);
-    lua_rawgeti(L, -1, info->hash);
-    // Stack: [mt, buckets, bucket]
-    if (lua_isnil(L, -1)) {
-        luaL_error(L, "Failed to find hash bucket for hash: %d", info->hash);
-    }
-    lua_pushvalue(L, 1);
-    // Stack: [mt, buckets, bucket, inst_udata]
-    lua_rawget(L, -2);
-    // Stack: [mt, buckets, bucket, inst_table]
-    return 1;
-}
-
 static int Lhash(lua_State *L)
 {
     luaL_checktype(L, 1, LUA_TUSERDATA);
@@ -613,34 +706,33 @@ static int Lhash(lua_State *L)
 
 static const luaL_Reg Rinstance_metamethods[] =
 {
-    { "__len", Llen},
+    {"__len", Llen},
-    { "__rawlen", Llen},
+    {"__rawlen", Llen},
-    { "__index", Lindex},
+    {"__index", Lindex},
-    { "__rawindex", Lindex},
+    {"__rawindex", Linst_index},
-    { "__tostring", Ltostring},
+    {"__tostring", Ltostring},
-    { "__rawtostring", Ltostring},
+    {"__rawtostring", Ltostring},
-    { "__ipairs", Lipairs},
+    {"__ipairs", Lipairs},
-    { "__rawipairs", Lipairs},
+    {"__rawipairs", Lipairs},
-    { "__pairs", Lpairs},
+    {"__pairs", Lpairs},
-    { "__rawpairs", Lpairs},
+    {"__rawpairs", Lpairs},
-    { "__hash", Lhash},
+    {"__hash", Lhash},
-    { "from_table", Lfrom_table},
+    {"from_table", Lfrom_table},
-    { "is_instance", Lis_instance},
+    {"is_instance", Lis_instance},
-    { "table", Ltable},
+    {NULL, NULL}
-    { NULL, NULL}
 };
 
 static int Lmake_class(lua_State *L)
 {
-    size_t n_args = lua_gettop(L);
+    size_t num_args = lua_gettop(L);
     // immutable([fields], [methods/metamethods])
-    lua_createtable(L, 0, 20); // Rough guess, 20 fields from Rinstance_metamethods + __fields, etc.
+    lua_createtable(L, 0, 24); // Rough guess of number of fields from Rinstance_metamethods + __fields, etc.
     // Stack: [CLS]
     // Populate CLS.__len, CLS.__index, CLS.__pairs, etc.
     luaL_register(L,NULL,Rinstance_metamethods);
 
     // If methods were passed in, copy them over, overwriting defaults if desired
-    if (lua_type(L, 2) == LUA_TTABLE) {
+    if (num_args >= 2 && lua_type(L, 2) == LUA_TTABLE) {
         // Stack: [CLS]
         lua_pushnil(L);
         // Stack: [CLS, nil]
@@ -677,7 +769,7 @@ static int Lmake_class(lua_State *L)
     lua_setfield(L, -2, "__buckets");
 
     // Stack: [CLS]
-    switch (n_args == 0 ? LUA_TNIL : lua_type(L, 1)) {
+    switch (num_args == 0 ? LUA_TNIL : lua_type(L, 1)) {
         case LUA_TTABLE: {
             // CLS.__fields = arg1
             lua_pushvalue(L, 1);
@@ -700,7 +792,11 @@ static int Lmake_class(lua_State *L)
             break;
         }
         case LUA_TNIL: case LUA_TNONE: {
-            // If no fields were passed in, so leave __fields and __indices empty
+            // If no fields were passed in, set __fields and __indices to empty tables
+            lua_createtable(L, 0, 0);
+            lua_setfield(L, -2, "__fields");
+            lua_createtable(L, 0, 0);
+            lua_setfield(L, -2, "__indices");
             break;
         }
         default: {

tests.lua

@@ -67,7 +67,9 @@ test("Testing indexing", function()
 end)
 
 test("Testing # operator", function()
-    assert(#v == 2)
+    assert(#v == 0)
+    local T = immutable()
+    assert(#T(1,2,3) == 3)
 end)
 
 test("Testing method", function()
@@ -79,6 +81,8 @@ test("Testing tostring", function()
 end)
 
 test("Testing from_table", function()
+    assert(Vec:from_table({x=1,y=2}) == Vec(1,2))
+    assert(Vec:from_table({3, x=1,y=2}) == Vec(1,2,3))
     assert(Vec:from_table(setmetatable({y=3}, {__index={x=1}})) == v)
     assert(Vec:from_table({x=1}) == Vec(1, nil))
 end)
@@ -108,10 +112,6 @@ test("Testing singletons", function()
     assert(T1() ~= T2())
 end)
 
-test("Testing extra args", function()
-    assert(not pcall(function() Vec(1,2,3) end))
-end)
-
 test("Testing __add metamethod", function()
     assert(v + Vec(5,6) == Vec(6,9))
 end)
@@ -161,15 +161,6 @@ test("Testing garbage collection", function()
     assert(next(Foo.__instances) == nil)
 end)
 
-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)
@@ -179,6 +170,20 @@ test("Testing __index", function()
     assert(f.x == "foo" and f.y == "foo" and f.z == "foo" and f.asdf == "foo")
 end)
 
+test("Testing __rawindex", function()
+    local Foo = immutable({"x","y"}, {
+        classvar = 99,
+        __index=function(self,k)
+            local cls = getmetatable(self)
+            local inst_val, found = cls.__rawindex(self, k)
+            if found then return inst_val end
+            return cls[k] or 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 similar class", function()
     FooVec = immutable({"x","y"}, {
         len2=function(self)
@@ -214,14 +219,15 @@ end)
 
 if _VERSION == "Lua 5.3" then
     test("Testing unpacking", function()
+        local Tuple = immutable()
         if table.unpack then
-            local a, b = table.unpack(Vec(5,6))
+            local a, b = table.unpack(Tuple(5,6))
             assert(a == 5 and b == 6)
         end
     end)
 end
 
-test("Testing immutable(n)", function()
+test("Testing immutable(nil)", function()
     local Tup3 = immutable(nil, {name="Tuple"})
     assert(tostring(Tup3(1,2,3)) == "Tuple(1, 2, 3)")
 end)
@@ -241,7 +247,7 @@ end)
 
 test("Testing giant immutable table", function()
     local keys = {}
-    local N = 10000
+    local N = 100000
     for i=1,N do keys[i] = "key_"..tostring(i) end
     local T = immutable(keys)
     local values = {}
@@ -273,12 +279,6 @@ if _VERSION == "Lua 5.2" or _VERSION == "Lua 5.3" then
         local f = Foo(1,nil,2,nil)
         local checks = {1,nil,2,nil}
         local passed = 0
-        for i,v in ipairs(f) do
-            assert(checks[i] == v)
-            passed = passed + 1
-        end
-        assert(passed == 4)
-        passed = 0
         checks = {x=1,y=nil,z=2,w=nil}
         for k,v in pairs(f) do
             assert(checks[k] == v)
@@ -326,6 +326,22 @@ test("Testing __hash", function()
     assert(T.__instances[h][t])
 end)
 
+test("Testing __rawindex", function()
+    local T = immutable({"x"}, {
+        classvar = 99,
+        __index = function(self, key)
+            local cls = getmetatable(self)
+            local value, found = cls.__rawindex(self, key)
+            if not found then
+                return cls[key]
+            else
+                return tostring(value)
+            end
+        end
+    })
+    assert(T(3).x == "3" and T(nil).x == "nil" and T(1).classvar == 99)
+end)
+
 if num_errors == 0 then
     print(green.."All tests passed!"..reset)
 else