Dans la programmation, on commence souvent par écrire des boucles impératives. Simples, efficaces… mais vite limitées. Prenons un exemple concret : une boucle for qui affiche les valeurs de i de 1 à 3.

for ($i = 1; $i <= 3; $i++) { echo $i . PHP_EOL; }

On peut représenter ce for sous forme de graphe :

• Initialisation i = 1

• Test de condition i <= 3 ?

• Exécution du corps de la boucle (print i)

• Incrément i = i + 1

• Retour à la condition tant qu’elle est vraie

• Sortie quand la condition devient fausse

Visuellement, cela donne un cycle avec plusieurs nœuds et flèches. Ce type de graphe fonctionne, mais il a un problème majeur : plus le programme grossit, plus le graphe devient illisible. On se retrouve avec des dizaines de nœuds, des flèches dans tous les sens… et la lecture devient un vrai casse-tête.

Au lieu de raisonner en graphe 2D, on peut réduire la boucle à une transformation linéaire. On passe d’un état initial (i = 1), on applique une fonction qui gère la récursion, et on arrive à la sortie (Exit). Tout est aligné verticalement comme un pipeline de données.

Schématiquement :

i = 1 ↓ Y (récursion) ↓ Exit

Ici, le Y Combinator joue le rôle clé : il permet d’exprimer la récursion dans un langage fonctionnel sans avoir besoin de nommer explicitement la fonction. La récursion devient un nœud unique dans le pipe, au lieu d’un enchevêtrement de flèches dans un graphe.

// Définition du Y Combinator $Y = fn($F) => (function ($x) use ($F) { return $F(function (...$args) use ($x, $F) { return $x($x)(...$args); }); })(fn($x) => $F(function (...$args) use ($x, $F) { return $x($x)(...$args); })); // Boucle for transformée en pipe récursif $step = function ($state) { ['i'=>$i,'max'=>$max] = $state; if ($i > $max) return [$state, true]; echo $i . PHP_EOL; return [['i'=>$i+1,'max'=>$max], false]; }; $recurse = $Y(function ($self) { return function ($state, $step) use ($self) { [$next, $done] = $step($state); return $done ? $next : $self($next, $step); }; }); $init = ['i'=>1,'max'=>3]; $recurse($init, $step);

Sortie :

1 2 3

• Lisibilité : un pipe linéaire est beaucoup plus simple à comprendre qu’un graphe 2D.

• Modularité : chaque étape est une fonction pure qui peut être testée et réutilisée.

• Puissance : le Y Combinator permet d’exprimer la récursion sans dépendre de l’impératif.

• Élégance : la structure est claire, de haut en bas, comme un flux de données.

Les graphes de nœuds sont utiles pour des cas rapides, mais ils deviennent vite des code spaghetti visuels. En adoptant une approche fonctionnelle avec des pipes et des combinators, on gagne en lisibilité, en réutilisabilité et en puissance expressive.

👉 Ne dessinez plus vos boucles comme des graphes 2D. Exprimez-les comme des pipes fonctionnels. C’est plus concis, plus clair, et ça ouvre la porte à des abstractions bien plus riches.

✨ Si tu veux aller plus loin :

• Documentation Flow

🎁 Je propose des séances de coaching gratuites de 30 minutes pour aider les créateurs comme vous à automatiser leurs processus et à gagner du temps ⏱️

👉 Réservez votre séance gratuite ici :

Merci de votre lecture ! Créons ensemble des workflows intelligents, rapides et automatisés 💻⚡