Question

What is the difference between tables and metatables in Corona? What are the types of metatables? How and where can I use them? What is the main purpose of using tables and metatables?

Answer 1

Lua (which is the language that Corona is based on) uses metatables for different purposes.

The relevant entry in the manual is Section 2.8.
A nice tutorial can be found here or here.

A metatable is just a table like any other, but is set as metatable on another table (which I’ll call a base table further on, to make a difference between the 2 tables).

A metatable can contain anything, but the special keys (starting with a double underscore) are the interesting ones. The values set to this keys in this table will be called on special occasions. Which occasion depends on which key. The most interesting are:

• __index: Will be used whenever a key in the base table is looked up, but does not exist. This can either contain table, in which the key will be looked up instead, or a function, which will be passed the original table and the key. This can be used for implementing methods on tables (OOP style), for redirection, fall through cases, setting defaults, etc etc
• __newindex: Will be used whenever a new key is to be assigned in a table (which was previously nil). If it’s a table, the key will be assigned in that table. If it’s a function, that function will be passed the original table, key and value. This can be used for controlling access to a table, preprocessing data, redirection of assignments.
• __call: enables you to set a function to be called if you use eg. table().
• __add,__sub,__mul,__div,__mod are used to implement binary operations,
• __unm is used to implement unary operations,
• __concat is used for implementing concatenation (the .. operator)
• __len is used for implementing the length operator (#)
• __eq,__lt,__le are used for implementing comparisons

A small thing to know when using __index & co.: in those methods, you should use rawget and rawset in order to prevent calling the metamethod each time again, causing a loop.
As a small example:

t={1,2,3}  -- basetable
mt={} -- metatable
mt.__index=function(t,k)
    print("__index event from "..tostring(t).." key "..k)
    return "currently unavailable"
end
mt.__newindex=function(t,k,v)
    print("__newindex event from "..tostring(t).." key: "..k.." value: "..v)
    if type(k)=="string" then
        rawset(t,k,v:reverse())
    else
        rawset(t,k,v)
    end
end
mt.__call=function(t,...)
    print("call to table "..tostring(t).." with arguments: ".. table.concat({...},','))
    print("All elements of the table:")
    for k,v in pairs(t) do print(k,v) end
end
setmetatable(t,mt)

t[4]="foo" -- this will run the __newindex method
print(t[5]) -- this will run the __index method
t("foo","bar")
-- Multiple fall through example:
t={}
mt={}
mt2={}
setmetatable(t,mt)  -- metatable on base table
setmetatable(mt,mt2) -- second layer of metatable
mt.__index=function(t,k) print('key '..k..' not found in '..namelookup[t]) return getmetatable(t)[k] end -- tries looking nonexistant indexes up in mt.
mt2.__index=mt.__index -- function was written portably, reuse it.

t[1]='A'
mt[2]='B'
mt2[3]='C'
namelookup={[t]="t",[mt]="mt",[mt2]="mt2"}
print(t[1],t[2],t[3],t[4])

Now these are but silly examples, you can do much more complex stuff. Take a look at the examples, take a look at the relevant chapters in Programming in Lua, and experiment. And try not to get confused 😉