Lua Academy · Lezione

Comporre funzioni

Concateni le trasformazioni.

Comporre funzioni è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Che cos'è la composizione?

La composizione di funzioni combina due funzioni in una sola. La funzione composta passa il proprio input attraverso la prima funzione, quindi passa il risultato alla seconda.

In matematica si scrive f(g(x)). La composizione consente di costruire trasformazioni complesse a partire da funzioni piccole e mirate.

Comporre due funzioni

Un helper compose accetta due funzioni e ne restituisce una nuova. Quando viene chiamato, esegue prima g, quindi passa il risultato a f.

L'ordine è importante: la funzione interna viene eseguita per prima, mentre la funzione esterna opera sul suo risultato.

local function compose(f, g)
  return function(x)
    return f(g(x))
  end
end

local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end

local incThenDouble = compose(dbl, inc)
print(incThenDouble(3))

L'ordine è importante

Scambiare gli argomenti cambia il risultato. compose(f, g) significa applicare prima g e poi f.

L'esempio seguente mostra che raddoppiare e poi incrementare produce un risultato diverso dall'incrementare e poi raddoppiare.

local function compose(f, g) return function(x) return f(g(x)) end end
local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end

print(compose(dbl, inc)(3))
print(compose(inc, dbl)(3))

Comporre funzioni sulle stringhe

La composizione funziona con qualsiasi funzione a un solo argomento, comprese le trasformazioni di stringhe. È possibile concatenare la rimozione degli spazi, la modifica delle maiuscole e minuscole o l'inversione in un unico passaggio riutilizzabile.

Qui reverse viene eseguita per prima, poi upper, ottenendo una stringa invertita e convertita in maiuscolo.

local function compose(f, g) return function(x) return f(g(x)) end end

local shout = compose(string.upper, string.reverse)
print(shout("lua"))

Comporre molte funzioni

Per concatenare più di due funzioni, scriva una composeAll variadica. Applica le funzioni da destra a sinistra, come nelle chiamate annidate.

Il ciclo percorre all'indietro l'elenco delle funzioni, facendo passare il valore attraverso ciascuna di esse.

local function composeAll(...)
  local fns = {...}
  return function(x)
    for i = #fns, 1, -1 do
      x = fns[i](x)
    end
    return x
  end
end

local f = composeAll(function(n) return n + 1 end,
  function(n) return n * 2 end,
  function(n) return n - 3 end)
print(f(10))

Da destra a sinistra

In composeAll(a, b, c), la funzione più a destra c viene eseguita per prima, poi b e infine a. Questo corrisponde alla forma annidata a(b(c(x))).

Leggere l'ordine può essere difficile, perciò alcuni preferiscono una pipe da sinistra a destra.

Una pipe da sinistra a destra

Una pipe inverte l'ordine di lettura: le funzioni vengono eseguite da sinistra a destra, nell'ordine in cui sono scritte. Molti la trovano più facile da seguire nelle pipeline di dati.

Il ciclo procede in avanti, applicando ogni funzione al valore corrente.

local function pipe(...)
  local fns = {...}
  return function(x)
    for i = 1, #fns do
      x = fns[i](x)
    end
    return x
  end
end

local process = pipe(function(n) return n + 1 end,
  function(n) return n * 2 end)
print(process(5))

Pipe per una maggiore leggibilità

Con pipe, i passaggi si leggono dall'alto verso il basso, nell'ordine di esecuzione. Questo rende autoesplicite le trasformazioni composte da più fasi.

Qui a una stringa viene rimosso un prefisso, poi viene convertita in minuscolo e infine invertita: ogni passaggio è elencato nell'ordine in cui avviene.

local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end

local transform = pipe(string.lower, string.reverse,
  function(s) return "[" .. s .. "]" end)
print(transform("LUA"))

Composizione con le closure

È possibile comporre funzioni create tramite applicazione parziale o closure. Costruisca piccole funzioni specializzate, quindi le colleghi tra loro.

In questo modo ogni componente rimane facilmente testabile, mentre la composizione esprime il flusso complessivo.

local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end
local function adder(n) return function(x) return x + n end end
local function muller(n) return function(x) return x * n end end

local calc = pipe(adder(3), muller(10))
print(calc(2))

Composizione e pipeline

La composizione è il collante alla base delle pipeline di dati. Invece di annidare profondamente le chiamate, assegni una volta un nome alla funzione composta e la applichi a molti input.

Funziona particolarmente bene con map: passi una funzione composta come trasformazione per ogni elemento.

local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function compose(f, g) return function(x) return f(g(x)) end end

local step = compose(function(n) return n + 1 end, function(n) return n * n end)
local r = map({1, 2, 3, 4}, step)
print(table.concat(r, ", "))

Mantenga le funzioni piccole

La composizione valorizza le funzioni piccole e con un unico scopo. Ognuna svolge un compito, e combinandole è possibile creare comportamenti complessi senza riscrivere la logica.

Questo è il cuore della progettazione funzionale: costruire un vocabolario di piccole funzioni e comporle per esprimere concetti più ampi.

Verifica rapida

Tracci con attenzione l'ordine prima di rispondere.

Riepilogo

La composizione combina le funzioni in modo che l'output di una diventi l'input della successiva. compose(f, g) esegue prima g e poi f, da destra a sinistra, mentre pipe procede da sinistra a destra per una maggiore leggibilità.

Con composeAll e pipe può concatenare molte funzioni piccole in pipeline chiare, particolarmente efficaci insieme a map.

Domande Frequenti

La lezione «Comporre funzioni» è gratuita?

Sì — il testo completo di «Comporre funzioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Comporre funzioni»?

Concateni le trasformazioni. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Comporre funzioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Lua Academy