Compondo funções
Encadeie transformações.
Compondo funções é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.
O que é composição?
A composição de funções combina duas funções em uma. A função composta passa sua entrada pela primeira função e, em seguida, envia esse resultado para a segunda.
Na matemática, isso é escrito como f(g(x)). A composição permite criar grandes transformações a partir de funções pequenas e focadas.
Compondo duas funções
Um auxiliar compose recebe duas funções e retorna uma nova. Chamá-lo executa g primeiro e, em seguida, passa o resultado para f.
A ordem é importante: a função interna é executada primeiro, e a função externa opera sobre sua saída.
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))A ordem é importante
Trocar os argumentos altera o resultado. compose(f, g) significa aplicar g primeiro e depois f.
O exemplo abaixo mostra que dobrar e depois incrementar produz uma resposta diferente de incrementar e depois dobrar.
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))Compondo funções de texto
A composição funciona com quaisquer funções de argumento único, incluindo transformações de texto. Encadeie remoção de espaços, alteração de maiúsculas e minúsculas ou inversão em uma única etapa reutilizável.
Aqui, reverse é executada primeiro e depois upper, produzindo um texto invertido com todas as letras em maiúsculas.
local function compose(f, g) return function(x) return f(g(x)) end end
local shout = compose(string.upper, string.reverse)
print(shout("lua"))Compondo várias funções
Para encadear mais de duas funções, escreva uma composeAll variádica. Ela aplica as funções da direita para a esquerda, como chamadas aninhadas.
O laço percorre a lista de funções de trás para frente, encadeando o valor por cada uma delas.
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 direita para a esquerda
Em composeAll(a, b, c), a função mais à direita, c, é executada primeiro, depois b e então a. Isso corresponde à forma aninhada a(b(c(x))).
Ler essa ordem pode ser complicado, por isso algumas pessoas preferem um fluxo da esquerda para a direita.
Um fluxo da esquerda para a direita
Um pipe inverte a ordem de leitura: as funções são executadas da esquerda para a direita, na ordem em que foram escritas. Muitas pessoas consideram isso mais fácil de acompanhar em fluxos de processamento de dados.
O laço avança, aplicando cada função ao valor acumulado.
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))Fluxo para facilitar a leitura
Com pipe, as etapas são lidas de cima para baixo, na ordem de execução. Isso torna as transformações em várias etapas autoexplicativas.
Aqui, um texto tem uma ideia de prefixo removida, é convertido para minúsculas e depois invertido, com cada etapa listada na ordem em que acontece.
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"))Composição com fechamentos
Você pode compor funções criadas por aplicação parcial ou por fechamentos. Crie funções pequenas e especializadas e depois una-as.
Isso mantém cada parte testável, enquanto a composição expressa o fluxo geral.
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))Composição e fluxos de processamento
A composição é o elemento de ligação por trás dos fluxos de processamento de dados. Em vez de aninhar chamadas profundamente, você nomeia uma função composta uma vez e a aplica a muitas entradas.
Isso funciona muito bem com map: passe uma função composta como transformação de cada item.
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, ", "))Mantenha as funções pequenas
A composição valoriza funções pequenas e de propósito único. Cada uma executa uma tarefa, e você as combina para formar comportamentos complexos sem reescrever a lógica.
Esse é o cerne do projeto funcional: crie um vocabulário de funções minúsculas e depois componha-as para expressar ideias maiores.
Verificação rápida
Acompanhe a ordem com atenção antes de responder.
Recapitulação
A composição combina funções para que a saída de uma seja passada à próxima. compose(f, g) executa g e depois f, da direita para a esquerda, enquanto pipe executa da esquerda para a direita para facilitar a leitura.
Com composeAll e pipe, você encadeia muitas funções pequenas em fluxos de processamento claros, especialmente eficazes quando combinados com map.
Perguntas Frequentes
A aula “Compondo funções” é grátis?
Sim — o texto completo de “Compondo funções” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.
O que vou aprender em “Compondo funções”?
Encadeie transformações. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Lua Academy?
Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Compondo funções”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Lua Academy?
Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Funções como valores
- map, filter, reduce
- Aplicação parcial
- Compondo funções