Lua Academy · Leçon

Application partielle

Préremplissez les arguments des fonctions.

Application partielle est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que l'application partielle ?

L'application partielle consiste à fixer maintenant certains arguments d'une fonction et à fournir les autres plus tard. Vous obtenez une nouvelle fonction qui nécessite moins d'arguments.

Vous pouvez ainsi transformer une fonction générale en fonction spécialisée en fixant les valeurs que vous connaissez déjà.

Un exemple manuel

Supposons que vous disposiez d'une fonction add. Vous pouvez créer addFive en écrivant une fermeture qui capture 5 et attend le deuxième nombre.

La valeur capturée reste dans la fonction renvoyée ; chaque appel n'a donc besoin que de l'argument restant.

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

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

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

Fixer le premier argument

Vous pouvez généraliser ce modèle. Une fonction auxiliaire bind1 reçoit une fonction et un premier argument fixe, puis renvoie une nouvelle fonction qui attend le deuxième.

La fermeture capture à la fois f et la valeur fixée, puis transmet tous les arguments au moment de l'appel.

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

Utiliser des arguments variables

Pour fixer un nombre quelconque d'arguments initiaux, utilisez la syntaxe Lua des arguments variables .... Capturez les arguments fixes, puis ajoutez les autres au moment de l'appel.

Les fonctions table.pack et table.unpack vous aident à stocker et à déployer les listes d'arguments.

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

Figer plusieurs arguments

Comme partial accepte un nombre variable d’arguments, vous pouvez figer plusieurs arguments à la fois. La fonction renvoyée n’a alors besoin que des arguments restants.

Ici, deux des trois arguments sont préremplis, ce qui laisse une fonction à un seul argument.

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

Une utilisation concrète

L’application partielle est particulièrement utile avec les fonctions utilitaires générales. Fixez la configuration une fois, puis réutilisez plusieurs fois la fonction spécialisée.

Ci-dessous, une fonction générique greet devient une fonction de salutation dans une langue fixe, qui n’a besoin que d’un nom.

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

Application partielle ou currification

La currification transforme une fonction à plusieurs arguments en une chaîne de fonctions à un seul argument, chacune renvoyant la suivante. L’application partielle se contente de fixer certains arguments et conserve les autres dans un appel normal.

Ces notions sont liées, mais distinctes : la currification procède un argument à la fois, tandis que l’application partielle en fixe certains immédiatement.

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

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

Currifier une fonction à deux arguments

Une petite fonction utilitaire peut currifier automatiquement toute fonction à deux arguments. Elle renvoie une fonction prenant le premier argument, qui renvoie elle-même une fonction prenant le second.

Cela produit des fonctions de construction réutilisables à un seul argument, qui s’intègrent agréablement dans les chaînes de traitement.

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

Les fermetures rendent cela possible

Toute fonction partiellement appliquée ou curryfiée repose sur des fermetures. Les arguments figés sont des variables locales capturées dont la fonction renvoyée se souvient.

Comme chaque fonction renvoyée possède ses propres valeurs capturées, vous pouvez créer de nombreuses variantes spécialisées en toute sécurité.

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

Quand l’utiliser

Utilisez l’application partielle pour éviter les répétitions lorsque vous appelez sans cesse une fonction avec les mêmes arguments initiaux.

Elle aide également à adapter une fonction à une interface qui attend moins d’arguments, comme une fonction de rappel qui ne transmet qu’une seule valeur.

Fonctions de rappel configurées

L’application partielle s’associe bien à la projection et au filtrage. Vous pouvez préremplir un argument de configuration afin que la fonction de rappel ne reçoive que l’élément de la liste.

Votre chaîne de traitement reste ainsi claire, tout en vous permettant d’ajuster le comportement.

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

Vérification rapide

Rappelez-vous la différence entre deux notions liées.

Récapitulatif

L’application partielle fige certains arguments et renvoie une nouvelle fonction qui attend les autres, grâce à des fermetures qui capturent les valeurs figées.

Une fonction utilitaire partial fondée sur un nombre variable d’arguments généralise cette approche, tandis que la currification enchaîne des fonctions à un seul argument. Toutes deux réduisent les répétitions et adaptent les fonctions aux fonctions de rappel.

Questions Fréquemment Posées

La leçon « Application partielle » est-elle gratuite ?

Oui — le texte complet de « Application partielle » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Application partielle » ?

Préremplissez les arguments des fonctions. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Application partielle » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Lua Academy