Added __hash method.

README.md

@@ -70,7 +70,7 @@ 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.
+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.
 ```lua
 local Foo = immutable({"x","y","xy"}, {
     __new = function(cls, x, y)
@@ -91,6 +91,27 @@ local Foo = immutable({"x","y"}, {
 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`:
+```lua
+local Foo
+Foo = immutable({"x","y"}, {
+    classvar = 23,
+    __index = function(self, key)
+        local cls = getmetatable(self)
+        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
+            local value = cls[key]
+            return value == nil and "undefined value" or value
+        end
+    end
+})
+local f = Foo(1,nil)
+assert(f.x == 1 and f.y == "nil inst value" and f.classvar == 23 and f.asdf == 999)
+```
 
 ## 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.

limmutable.c

@@ -602,6 +602,14 @@ static int Ltable(lua_State *L)
     return 1;
 }
 
+static int Lhash(lua_State *L)
+{
+    luaL_checktype(L, 1, LUA_TUSERDATA);
+    immutable_info_t *info = (immutable_info_t *)lua_touserdata(L, 1);
+    lua_pushinteger(L, info->hash);
+    return 1;
+}
+
 static const luaL_Reg Rinstance_metamethods[] =
 {
     { "__len", Llen},
@@ -609,6 +617,7 @@ static const luaL_Reg Rinstance_metamethods[] =
     { "__tostring", Ltostring},
     { "__ipairs", Lipairs},
     { "__pairs", Lpairs},
+    { "__hash", Lhash},
     { "from_table", Lfrom_table},
     { "is_instance", Lis_instance},
     { "table", Ltable},

tests.lua

@@ -318,6 +318,14 @@ test("Testing __new with varargs", function()
     assert(f[1] == "prefix" and f[2] == 1 and f[3] == 2 and f[4] == nil)
 end)
 
+test("Testing __hash", function()
+    local T = immutable()
+    local t = T(1,2,3)
+    local h = t:__hash()
+    assert(type(h) == 'number')
+    assert(T.__instances[h][t])
+end)
+
 if num_errors == 0 then
     print(green.."All tests passed!"..reset)
 else