Funciones anónimas vs no anónimas Lua

Question

Estoy aprendiendo Lua y me he encontrado con el concepto de funciones anónimas. Es interesante, pero me preguntaba qué ventaja adicional proporciona sobre las funciones no anónimas.

lo que si tengo algo así como

function(a,b) return (a+b) end 

La función es anónima y si tengo

function add(a,b) return (a+b) end 

La función es no anónimo. El segundo es mejor porque puedo llamarlo donde quiera y también sé lo que está haciendo mi función. Entonces, ¿cuál es la ventaja de las funciones anónimas? ¿Me estoy perdiendo de algo?

Answer 1

Para ser sincero, no existe una función llamada en Lua. Todas las funciones son en realidad anónimas, pero se pueden almacenar en variables (que tienen un nombre).

El llamado función sintaxis function add(a,b) return a+b end es en realidad un syntactic sugar para add = function(a,b) return a+b end.

Las funciones son a menudo utilizados como controladores de eventos y de decisiones que una biblioteca no/no puede saber, el ejemplo más famoso es table.sort() - la utilización de su función, puede especificar el orden de clasificación:

people = {{name="John", age=20}, {name="Ann", age=25}} 
table.sort(people, function (a,b) return a.name < b.name end) 

El punto es que lo más probable es que no necesites la función más tarde. Por supuesto, también se puede ahorrar la función de una variable (posiblemente local) y el uso que:

local nameComparator = function (a,b) return a.name < b.name end 
table.sort(people, nameComparator) 

Para obtener más información, lea este section on functions in PiL.

Answer 2

El segundo ejemplo es equivalente al
add = function(a,b) return a+b end
Así que en realidad está utilizando funciones anónimas todo el tiempo, en un sentido trivial.

Pero las funciones anónimas pueden ser mucho más útiles en otros contextos. Por ejemplo, el uso de funciones para mutar otras funciones (el alma de la programación funcional.)

function make_version_with_n_args (func, n) 
    if n == 1 then 
     return function (x) return x end 
    else 
     return function (x, ...) 
      return func (x, make_version_with_n_args (func, n-1)(...)) 
     end 
    end 
end 

add_four = make_version_with_n_args (function (a, b) return a+b end, 4) 

print (add_four(3, 3, 3, 3)) 

add_sizes = {} 
for i = 1, 5 do 
    add_sizes[i] = make_version_with_n_args(function (a, b) return a+b end, i) 
end 

func_args = {} 
for i = 1, 5 do 
    func_args[#func_args+1] = 2 
    print (add_sizes[i](unpack(func_args))) 
end 

function make_general_version (func) 
    return function (...) 
     local args = {...} 
     local result = args[#args] 
     for i = #args-1,1,-1 do 
      result = func(args[i], result) 
     end 
     return result 
    end 
end 

general_add = make_general_version (function (a, b) return a+b end) 

print (general_add(4, 4, 4, 4)) 

Básicamente, se puede crear un nombre para cada función si se quiere, pero en situaciones en las que están tirando en torno a tantos funciones únicas, es más conveniente no hacerlo.