Programmation · paradigmes · concepts

Qu'est-ce que la programmation fonctionnelle ?

Vous avez sans doute déjà croisé les termes : « FP », « fonctions pures », « sans effets de bord », « Haskell ». La programmation fonctionnelle est une manière d'écrire des logiciels qui construit les programmes à partir de fonctions appliquées à des valeurs, plutôt qu'à partir de suites d'instructions modifiant un état partagé. Ce guide explique ce qu'elle est réellement, ses idées fondamentales, ce qui la distingue des styles impératif et objet, ses compromis honnêtes, et la place qu'y tient un langage comme Haskell.

La définition courte

La programmation fonctionnelle est un style qui construit les programmes en composant des fonctions pures et en évitant l'état mutable partagé. Vous décrivez ce que vous voulez calculer comme des transformations de valeurs, au lieu de détailler comment modifier des variables étape par étape. Les mêmes entrées produisent toujours les mêmes sorties, ce qui rend le code plus facile à raisonner et à tester.

Les idées fondamentales

Les fonctions pures. Une fonction pure ne dépend que de ses entrées et ne produit qu'une valeur de retour — aucune lecture ni écriture d'état extérieur, aucune surprise. Appelez-la avec les mêmes arguments et vous obtenez toujours le même résultat.

L'immuabilité. Au lieu de modifier des données sur place, on crée de nouvelles valeurs. Une liste « modifiée » est en fait une nouvelle liste ; l'originale reste intacte. Cela supprime toute une catégorie de bugs causés par une donnée qui change là où on ne s'y attendait pas.

Les fonctions comme valeurs de première classe. Les fonctions peuvent être passées en argument, renvoyées par d'autres fonctions et stockées dans des variables — on construit donc le comportement en combinant de petites fonctions. Une fonction qui prend ou renvoie une autre fonction s'appelle une fonction d'ordre supérieur, et map, filter et reduce en sont les exemples quotidiens.

Le déclaratif plutôt que l'impératif. Vous dites quel doit être le résultat, pas la suite exacte de boucles et de mutations pour y parvenir.

Un contraste rapide

Le code impératif boucle souvent en modifiant un total courant :

total = 0
for n in numbers:
    total = total + n      # on modifie 'total' a chaque etape

Le code fonctionnel exprime la même idée comme une transformation de valeurs, sans aucune mutation :

total = sum(map(double, numbers))   # decrire le resultat, pas les etapes

Les deux calculent un nombre ; la version fonctionnelle n'a aucun état changeant à suivre, ce qui la rend plus facile à tester et à paralléliser.

En quoi elle diffère de l'objet

La programmation orientée objet organise le code autour d'objets qui regroupent des données et des méthodes modifiant souvent ces données. La programmation fonctionnelle garde données et comportement séparés : les données sont des valeurs immuables, le comportement des fonctions pures qui les transforment. Les deux ne sont pas ennemies — beaucoup de langages modernes (Python, JavaScript, Kotlin, Scala) mélangent les deux — mais l'état d'esprit diffère : minimiser l'état et les effets de bord plutôt que les encapsuler et les modifier.

La place de Haskell

La plupart des langages courants sont multi-paradigmes et permettent d'écrire dans un style fonctionnel. Quelques-uns sont purement fonctionnels, et Haskell est le plus connu : la pureté et l'immuabilité n'y sont pas des commodités facultatives mais des règles imposées par le langage et son système de types, et les effets de bord (comme les entrées/sorties) y sont rendus explicites — c'est précisément à cela que servent les monades. Apprendre la programmation fonctionnelle dans un langage qui l'impose fait généralement comprendre les idées plus vite.

Les compromis honnêtes

Ce n'est pas une solution miracle. Les forces : un code plus facile à raisonner, à tester et à exécuter en parallèle, avec moins de bugs liés à l'état. Les coûts : une courbe d'apprentissage (récursion et fonctions d'ordre supérieur au lieu de boucles), et certains problèmes — mutation intensive sur place, chemins critiques pour la performance — s'expriment moins naturellement dans un style pur. En pratique, la plupart des équipes adoptent des habitudes fonctionnelles — fonctions pures, immuabilité là où elle aide — sans passer au tout-pur.

Questions fréquentes

Qu'est-ce que la programmation fonctionnelle, en termes simples ? Un style qui construit les programmes à partir de fonctions pures transformant des valeurs, en évitant l'état mutable partagé — si bien que les mêmes entrées donnent toujours les mêmes sorties.

Qu'est-ce qu'une fonction pure ? Une fonction dont le résultat ne dépend que de ses entrées et qui n'a aucun effet de bord (elle ne lit ni ne modifie d'état extérieur). C'est la brique de base du style fonctionnel.

La programmation fonctionnelle est-elle meilleure que l'objet ? Aucune n'est universellement meilleure. Le fonctionnel excelle en prévisibilité, en test et en parallélisme ; l'objet à modéliser des entités porteuses d'état. Beaucoup de langages permettent de combiner les deux.

Quels langages sont fonctionnels ? Haskell est purement fonctionnel. Beaucoup d'autres soutiennent bien le style : Scala, Elixir, Clojure, F#, et même Python et JavaScript grâce aux fonctions de première classe.

Le code fonctionnel reste fait, en dessous, de logique pas à pas — voir ce qu'est un algorithme — et l'endroit le plus pur pour apprendre le style reste Haskell. Parcourez d'autres explications claires dans notre index des guides.

Guides liés : comment fonctionne la récursion, qu'est-ce qu'une variable.