Lua Academy · Aula

Aplicação parcial

Preencha antecipadamente os argumentos das funções.

Aplicação parcial é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 3 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 é aplicação parcial

Aplicação parcial significa fixar agora alguns dos argumentos de uma função e fornecer o restante mais tarde. Você obtém uma nova função que precisa de menos argumentos.

Isso permite transformar uma função geral em uma função especializada, fixando os valores que você já conhece.

Um exemplo manual

Suponha que você tenha uma função add. Você pode criar addFive escrevendo um fechamento que captura 5 e espera pelo segundo número.

O valor capturado permanece na função retornada, portanto cada chamada precisa apenas do argumento restante.

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

local function addFive(b)
  return add(5, b)
end

print(addFive(10))
print(addFive(2))

Vinculando o primeiro argumento

Podemos generalizar esse padrão. Um auxiliar bind1 recebe uma função e um primeiro argumento fixo e retorna uma nova função que espera o segundo.

O fechamento captura f e o valor fixado e depois encaminha tudo quando é chamado.

local function bind1(f, a)
  return function(b)
    return f(a, b)
  end
end

local function mul(x, y) return x * y end
local double = bind1(mul, 2)
print(double(7))
print(double(50))

Usando argumentos variáveis

Para fixar qualquer quantidade de argumentos iniciais, use a sintaxe de argumentos variáveis de Lua, .... Capture os argumentos fixos e depois acrescente os demais no momento da chamada.

As funções table.pack e table.unpack ajudam a armazenar e expandir listas de argumentos.

local function partial(f, ...)
  local fixed = table.pack(...)
  return function(...)
    local rest = table.pack(...)
    local args = {}
    for i = 1, fixed.n do args[i] = fixed[i] end
    for i = 1, rest.n do args[fixed.n + i] = rest[i] end
    return f(table.unpack(args, 1, fixed.n + rest.n))
  end
end

local function add3(a, b, c) return a + b + c end
local add10 = partial(add3, 10)
print(add10(2, 3))

Fixando vários argumentos

Como partial aceita um número variável de argumentos, você pode fixar mais de um argumento de uma só vez. A função retornada precisa apenas dos argumentos restantes.

Aqui, dois de três argumentos são preenchidos previamente, deixando uma função com um único argumento.

local function partial(f, ...)
  local fixed = table.pack(...)
  return function(...)
    local rest = table.pack(...)
    local args = {}
    for i = 1, fixed.n do args[i] = fixed[i] end
    for i = 1, rest.n do args[fixed.n + i] = rest[i] end
    return f(table.unpack(args, 1, fixed.n + rest.n))
  end
end

local function label(prefix, sep, value) return prefix .. sep .. value end
local tag = partial(label, "id", ":")
print(tag(42))

Um uso prático

A aplicação parcial é especialmente útil com funções utilitárias genéricas. Fixe a configuração uma vez e reutilize muitas vezes a função especializada.

Aqui, uma função genérica greet se torna uma função de saudação em um idioma fixo que precisa apenas de um nome.

local function greet(lang, name)
  if lang == "tr" then return "Merhaba, " .. name end
  return "Hello, " .. name
end

local function bind1(f, a) return function(b) return f(a, b) end end
local greetTr = bind1(greet, "tr")
print(greetTr("Ada"))
print(greetTr("Lin"))

Aplicação parcial vs. currificação

A currificação transforma uma função com vários argumentos em uma cadeia de funções com um único argumento, cada uma retornando a próxima. A aplicação parcial apenas fixa alguns argumentos e mantém os demais em uma chamada normal.

Elas estão relacionadas, mas são distintas: a currificação funciona um argumento por vez, enquanto a aplicação parcial fixa alguns argumentos de imediato.

local function curryAdd(a)
  return function(b)
    return function(c)
      return a + b + c
    end
  end
end

print(curryAdd(1)(2)(3))

Currificando uma função com dois argumentos

Um pequeno auxiliar pode currificar automaticamente qualquer função com dois argumentos. Ele retorna uma função do primeiro argumento, que retorna uma função do segundo.

Isso produz construtores reutilizáveis de argumento único, que ficam claros em fluxos de processamento.

local function curry2(f)
  return function(a)
    return function(b)
      return f(a, b)
    end
  end
end

local function pow(base, exp) return base ^ exp end
local cpow = curry2(pow)
print(cpow(2)(10))

Os fechamentos fazem isso funcionar

Toda função parcial ou currificada depende de fechamentos. Os argumentos fixados são variáveis locais capturadas que a função retornada mantém na memória.

Como cada função retornada tem seus próprios valores capturados, você pode criar muitas variantes especializadas com segurança.

local function bind1(f, a) return function(b) return f(a, b) end end
local function sub(x, y) return x - y end

local from100 = bind1(sub, 100)
local from10 = bind1(sub, 10)
print(from100(40))
print(from10(3))

Quando usar

Use a aplicação parcial para eliminar repetições quando você chama repetidamente uma função com os mesmos argumentos iniciais.

Ela também ajuda a adaptar uma função a uma interface que espera menos argumentos, como uma função de retorno de chamada que passa apenas um valor.

Funções de retorno de chamada configuradas

A aplicação parcial combina bem com map e filter. Você pode preencher previamente um argumento de configuração para que a função de retorno de chamada receba apenas o elemento da lista.

Isso mantém seu fluxo de processamento limpo, sem impedir que você ajuste o comportamento.

local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function bind1(f, a) return function(b) return f(a, b) end end
local function scale(factor, x) return factor * x end

local r = map({1,2,3,4}, bind1(scale, 10))
print(table.concat(r, ", "))

Verificação rápida

Relembre a diferença entre duas ideias relacionadas.

Recapitulação

A aplicação parcial fixa alguns argumentos e retorna uma nova função que espera os restantes, criada com fechamentos que capturam os valores fixados.

Um auxiliar partial baseado em argumentos variáveis generaliza isso, enquanto a currificação encadeia funções de argumento único. Ambos reduzem repetições e adaptam funções a funções de retorno de chamada.

Perguntas Frequentes

A aula “Aplicação parcial” é grátis?

Sim — o texto completo de “Aplicação parcial” é 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 “Aplicação parcial”?

Preencha antecipadamente os argumentos das funçõ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 3 de 4.

Quanto tempo leva a aula “Aplicação parcial”?

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

← Voltar para Lua Academy