Diferença entre . e: em Lua

Estou confuso sobre a diferença entre chamadas de função via .e via:

> x = {foo = function(a,b) return a end, bar = function(a,b) return b end, }
> return x.foo(3,4)
3
> return x.bar(3,4)
4
> return x:foo(3,4)
table: 0x10a120
> return x:bar(3,4)
3

O que está :fazendo?

Os dois pontos são para implementar métodos que passam selfcomo o primeiro parâmetro. Então x:bar(3,4)deve ser o mesmo que x.bar(x,3,4).

Para definição, é exatamente o mesmo que especificar manualmente - ele até produzirá o mesmo bytecode na compilação. Ou seja, function object:method(arg1, arg2)é o mesmo que function object.method(object, arg1, arg2).

O uso :é quase o mesmo que .- um tipo especial de chamada será usado internamente para garantir que objecttodos os possíveis efeitos colaterais dos cálculos / acesso sejam calculados apenas uma vez. Chamar object:method(arg1, arg2)é o mesmo que object.method(object, arg1, arg2).

Para ser completamente preciso, obj:method(1, 2, 3)é o mesmo que

do
  local _obj = obj
  _obj.method(_obj, 1, 2, 3)
end

Por que a variável local? Porque, como muitos apontaram, obj:method()apenas os índices são obtidos _ENVuma vez obj. Isso normalmente é importante ao considerar a velocidade, mas considere esta situação:

local tab do
  local obj_local = { method = function(self, n) print n end }
  tab = setmetatable({}, {__index = function(idx)
    print "Accessing "..idx
    if idx=="obj" then return obj_local end
  end})
end
tab.obj.method(tab.obj, 20)
--> Accessing obj
--> Accessing obj
--> 20
tab.obj:method(10)
--> Accessing obj
--> 10

Agora imagine que o __indexmetamétodo fez mais do que apenas imprimir algo. Imagine que ele aumentou um contador, registrou algo em um arquivo ou excluiu um usuário aleatório do seu banco de dados. Há uma grande diferença entre fazer isso duas ou apenas uma vez. Nesse caso, há uma clara diferença entre obj.method(obj, etc)e obj:method(etc).