Simple Tuples

wiki

A very simple interned immutable 2-tuple implementation. Tuple members cannot be nil or NaN:

-- An interned 2-tuple type, in pure Lua.
--
do
  -- The constructor makes a tuple function, which has its own
  -- intern table.
        
  local setmetatable = setmetatable

  local function tmaker(a)
    return {__index = function(t, b)
                        local function tuple() return a, b end
                        t[b] = tuple
                        return tuple
                      end,
            __mode = "kv"
           }
  end 
  local meta = {
      __index = function(t, a)
                  local v = setmetatable({}, tmaker(a))
                  t[a] = v
                  return v
                end,
      __mode = "k"
  } 
  return function()
    local intern = setmetatable({}, meta)
    return function(a, b)
      return intern[a][b]
    end
  end
end

The __mode lines are optional; in practice, I use this with tuple-caches which are not long-lived, and it is easier to throw away the entire cache.

Usage: Put the above in a file named, for example, TupleCache.lua. Create a tuple function:

local FooTuple = require"TupleCache"()

Then you can create new FooTuples using the tuple function:

local t = FooTuple(obja, objb)

The FooTuple function itself has the only reference to the cache tables, so the cache tables will be garbage collected once FooTuple no longer has references. However, the tuples themselves will continue to exist; you simply cannot make new ones.

To extract the values of a tuple, call it:

local obja, objb = t()

If you really need tuples capable of containing nil and NaN, you can use this version:

do
  -- The constructor makes a tuple function, which has its own
  -- intern table.

  local rawget, setmetatable = rawget, setmetatable
  local NIL, NAN = {}, {}
  
  local function check(t, a)
    if a == a and a ~= nil then return a end
    local fixa = a and NAN or NIL
    return fixa, rawget(t, fixa)
  end

  local function tmaker(a)
    return {__index = function(t, b)
                        local fixb, tuple = check(t, b)
                        tuple = tuple or function() return a, b end
                        t[fixb] = tuple
                        return tuple
                      end
           }
  end
  local meta = {
      __index = function(t, a)
                  local fixa, v = check(t, a)
                  v = v or setmetatable({}, tmaker(a))
                  t[fixa] = v
                  return v
                end
  }
  return function()
    local intern = setmetatable({}, meta)
    return function(a, b)
      return intern[a][b]
    end
  end
end

Simple Tuples

See Also