Funzioni anonime e non anonime Lua

Question

Sto imparando Lua e ho trovato il concetto di funzioni anonime. È interessante ma mi stavo chiedendo quale ulteriore vantaggio fornisca sulle funzioni non anonime.

Quindi, se ho qualcosa di simile

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

La funzione è anonimo e se ho

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

La funzione è non anonimo. Il secondo è meglio perché posso chiamarlo dove voglio e so anche cosa sta facendo la mia funzione. Quindi, qual è il vantaggio delle funzioni anonime? Mi sto perdendo qualcosa qui?

Answer 1

Per essere onesti, non esiste una funzione denominata in Lua. Tutte le funzioni sono anonime, ma possono essere memorizzate in variabili (che hanno un nome).

Il nome funzione sintassi function add(a,b) return a+b end è in realtà un syntactic sugar per add = function(a,b) return a+b end.

funzioni vengono spesso utilizzati come gestori di eventi e per le decisioni che una libreria non/non può sapere, il più famoso esempio è table.sort() - di utilizzare la funzione, è possibile specificare il tipo di ordinamento:

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

Il punto è che molto probabilmente non ti servirà più tardi la funzione. Naturalmente, è anche possibile salvare la funzione a una variabile (possibilmente locale) e l'uso che:

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

Per ulteriori informazioni, leggere questo section on functions in PiL.

Answer 2

Il secondo esempio è equivalente a
add = function(a,b) return a+b end
Quindi, in realtà si sta utilizzando funzioni anonime per tutto il tempo, in un certo senso banale.

Ma le funzioni anonime possono essere molto più utili in altri contesti. Ad esempio, utilizzando le funzioni di mutare le altre funzioni (l'anima della programmazione funzionale.)

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)) 

In sostanza, è possibile creare un nome per ogni singola funzione, se si vuole, ma in situazioni in cui si stanno gettando in giro così tanti funzioni una tantum, è più conveniente non farlo.