La théorie des catégories offre un cadre d'abstraction pour raisonner sur les structures mathématiques et leurs relations. Haskell, langage fonctionnel, entretient avec elle un lien organique : catégories, foncteurs, applicatifs et monades se traduisent presque mot pour mot en constructions de programmation modulaires et composables.
1. Les catégories
Une catégorie se compose d'objets (les types en Haskell) et de morphismes (les fonctions), avec un morphisme identité `id :: A -> A` et une composition `g . f`. La composition doit être associative et l'identité jouer le rôle d'unité (`f . id == f`). En Haskell, les objets sont des types (`Int`, `String`, `[Bool]`), les morphismes des fonctions, l'identité `id` et la composition `(.)`. Ce cadre pousse à voir le calcul comme une composition de fonctions — le cœur même de la programmation fonctionnelle.
2. Les foncteurs
Un foncteur mappe objets et morphismes d'une catégorie à une autre en préservant composition et identité. En Haskell :
```haskell
class Functor f where
fmap :: (a -> b) -> f a -> f b
```
`fmap` applique une fonction au « contenu » d'un contexte `f a`. Ses lois : `fmap id == id` et `fmap (f . g) == fmap f . fmap g`. Exemples : `Maybe` (applique la fonction à l'intérieur d'un `Just`), `[]` (à chaque élément) ou `IO` (au résultat d'une action). Les foncteurs permettent ainsi d'opérer uniformément sur des valeurs en contexte, sans les emballer ni les désemballer manuellement.
3. Les foncteurs applicatifs
Un applicatif est un foncteur plus fort qui autorise l'application de fonctions elles-mêmes en contexte :
```haskell
class Functor f => Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
```
`pure` élève une valeur dans le contexte, `<*>` applique une fonction emballée à une valeur emballée. Lois principales : identité, homomorphisme, échange et composition. Les applicatifs excellent pour séquencer des calculs combinables, notamment parallélisables — d'où leur usage en analyse syntaxique, validation et gestion de la concurrence.
4. Les monades
Une monade est un applicatif encore plus puissant qui séquence des calculs dépendant des résultats précédents :
```haskell
class Applicative m => Monad m where
(>>=) :: m a -> (a -> m b) -> m b
```
L'opérateur `>>=` (bind) enchaîne des calculs où chacun peut dépendre du précédent, `return` (= `pure`) élève une valeur. Lois : identité gauche, identité droite et associativité. Exemples : `Maybe` (une étape `Nothing` fait échouer toute la séquence), `[]` (calculs non déterministes), `IO` (séquencement d'effets de bord, fondement de la pureté de Haskell) et `State` (propagation d'un état). La notation `do` n'est qu'un sucre syntaxique pour ces liaisons.
5. Les transformations naturelles
Une transformation naturelle est un morphisme entre foncteurs qui préserve leur structure — une fonction polymorphe `nt :: forall a. f a -> g a`. Par exemple, `maybeToList :: Maybe a -> [a]` (qui transforme `Just x` en `[x]` et `Nothing` en `[]`) en est une, contrairement à un `fromJust` partiel. Elles permettent de convertir proprement entre contextes et d'écrire du code indépendant du foncteur choisi.
Le lien avec la programmation fonctionnelle
Ces concepts se rejoignent autour de quelques principes : abstraction (raisonner sur la structure plutôt que l'implémentation), compositionnalité (l'opérateur `.` en est le reflet direct), modularité (les lois garantissent des comportements prévisibles), correction (les lois algébriques permettent des preuves formelles) et modèles de conception (la monade `Reader` illustre l'injection de dépendances).
Comprendre la théorie des catégories n'est pas indispensable pour débuter en Haskell, mais cela démultiplie votre capacité à concevoir et à raisonner sur des programmes fonctionnels complexes.