Lua Academy · Leçon

Composer des fonctions

Enchaînez les transformations.

Composer des fonctions est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 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 la composition ?

La composition de fonctions combine deux fonctions en une seule. La fonction composée fait passer son entrée dans la première fonction, puis transmet le résultat à la seconde.

En mathématiques, cela s’écrit f(g(x)). La composition permet de construire de grandes transformations à partir de petites fonctions ciblées.

Composer deux fonctions

Une fonction utilitaire compose prend deux fonctions et en renvoie une nouvelle. Son appel exécute d’abord g, puis transmet le résultat à f.

L’ordre est important : la fonction interne s’exécute en premier et la fonction externe s’exécute sur sa sortie.

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’ordre est important

Échanger les arguments modifie le résultat. compose(f, g) signifie appliquer g d’abord, puis f.

L’exemple ci-dessous montre que doubler puis incrémenter donne un résultat différent d’incrémenter puis doubler.

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

Composer des fonctions sur les chaînes

La composition fonctionne avec toutes les fonctions à un seul argument, notamment les transformations de chaînes. Vous pouvez enchaîner la suppression des espaces, la modification de la casse ou l’inversion pour former une seule étape réutilisable.

Ici, l’inversion s’effectue d’abord, puis la mise en majuscules, ce qui donne une chaîne inversée entièrement en majuscules.

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

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

Composer plusieurs fonctions

Pour enchaîner plus de deux fonctions, écrivez une fonction variadique composeAll. Elle applique les fonctions de droite à gauche, comme des appels imbriqués.

La boucle parcourt la liste des fonctions en sens inverse et transmet la valeur à chacune d’elles.

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

De droite à gauche

Dans composeAll(a, b, c), la fonction la plus à droite, c, s’exécute en premier, puis b, puis a. Cela correspond à la forme imbriquée a(b(c(x))).

Il peut être difficile de lire cet ordre, c’est pourquoi certaines personnes préfèrent un chaînage de gauche à droite.

Un chaînage de gauche à droite

Un pipe inverse l’ordre de lecture : les fonctions s’exécutent de gauche à droite, dans l’ordre où elles sont écrites. Beaucoup trouvent cette approche plus facile à suivre pour les chaînes de traitement de données.

La boucle parcourt les fonctions vers l’avant et applique chacune à la valeur courante.

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

Le chaînage pour plus de clarté

Avec pipe, les étapes se lisent de haut en bas, dans l’ordre d’exécution. Les transformations en plusieurs étapes s’expliquent ainsi d’elles-mêmes.

Ici, une chaîne est débarrassée d’un préfixe donné, convertie en minuscules, puis inversée, chaque étape étant listée dans l’ordre où elle se produit.

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

Composition et fermetures

Vous pouvez composer des fonctions créées par application partielle ou à l’aide de fermetures. Construisez de petites fonctions spécialisées, puis assemblez-les.

Chaque élément reste ainsi vérifiable, tandis que la composition exprime le déroulement général.

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

Composition et chaînes de traitement

La composition est le lien qui sous-tend les chaînes de traitement de données. Au lieu d’imbriquer profondément les appels, vous nommez une fonction composée une fois, puis vous l’appliquez à de nombreuses entrées.

Cela fonctionne particulièrement bien avec la projection : transmettez une fonction composée comme transformation de chaque élément.

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

Gardez des fonctions simples

La composition valorise les petites fonctions à usage unique. Chacune accomplit une tâche, et vous les combinez pour former un comportement complexe sans réécrire la logique.

C’est le cœur de la conception fonctionnelle : constituez un vocabulaire de minuscules fonctions, puis composez-les pour exprimer des idées plus vastes.

Vérification rapide

Suivez attentivement l’ordre avant de répondre.

Récapitulatif

La composition combine des fonctions afin que la sortie de l’une alimente la suivante. compose(f, g) exécute g puis f, de droite à gauche, tandis que pipe s’exécute de gauche à droite pour améliorer la lisibilité.

Avec composeAll et pipe, vous enchaînez de nombreuses petites fonctions dans des chaînes de traitement claires, particulièrement efficaces lorsqu’elles sont associées à la projection.

Questions Fréquemment Posées

La leçon « Composer des fonctions » est-elle gratuite ?

Oui — le texte complet de « Composer des fonctions » 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 « Composer des fonctions » ?

Enchaînez les transformations. 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 4 sur 4.

Combien de temps prend la leçon « Composer des fonctions » ?

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