Haskell · concepts · monades

Les monades en Haskell, expliquées sans le jargon

« Monade » a une réputation effrayante qu’elle ne mérite pas. Dépouillée du jargon, une monade en Haskell est simplement un type qui vous laisse séquencer des calculs qui portent un certain contexte — un échec possible, un effet de bord, plusieurs résultats — sans écrire la tuyauterie à la main à chaque fois. Ce guide explique ce qu’est réellement une monade, les deux opérations qui la définissent, la do-notation, et les monades du quotidien que vous utilisez déjà.

L’idée en une phrase

Une monade est un type doté d’un moyen de chaîner des étapes où chaque étape dépend du résultat de la précédente, et où le « contexte » (échec, effets, non-déterminisme) est propagé automatiquement. C’est tout. Les fameux types Maybe, Either, IO et liste sont tous des monades parce que chacun définit ce chaînage pour son propre type de contexte.

Les deux opérations

La typeclass Monad est définie par deux fonctions :

return :: a -> m a          -- wrap a plain value into the monad
(>>=)  :: m a -> (a -> m b) -> m b   -- "bind": feed the result into the next step

>>= (qu’on prononce « bind ») en est le cœur : il prend une valeur en contexte, et une fonction qui produit la valeur suivante en contexte, et les assemble — en gérant le contexte pour vous.

do-notation : la même chose, en lisible

Les blocs do ne sont que du sucre au-dessus de >>=. Ceux-ci sont équivalents :

-- with bind
getLine >>= \name -> putStrLn ("Hi " ++ name)

-- with do-notation
do name <- getLine
   putStrLn ("Hi " ++ name)

La do-notation vous laisse écrire du code séquencé porteur de contexte qui se lit comme des étapes impératives tout en restant purement fonctionnel.

Les monades que vous utilisez déjà

• Maybe — le contexte est « peut être absent ». Bind court-circuite sur Nothing, donc vous enchaînez des recherches sans vérifications de null imbriquées.
• Either — le contexte est « peut échouer avec une erreur ». Comme Maybe mais porte la raison de l’échec.
• IO — le contexte est « effectue des effets de bord ». La monade IO est la façon dont Haskell séquence les effets tout en restant pur ; main :: IO () est le point d’entrée.
• Liste ([]) — le contexte est « plusieurs résultats ». Bind explore chaque combinaison (non-déterminisme).

Vous utilisez des monades depuis votre tout premier main — IO en est une.

Pourquoi les monades comptent

Elles vous laissent abstraire la tuyauterie de la gestion d’échec, des effets et du séquencement en un motif réutilisable, pour que le même code en style do fonctionne à travers des contextes très différents. C’est pourquoi Haskell peut garder IO séparé et explicite tout en restant ergonomique. Pour exécuter tout cela, il vous faut la chaîne d’outils — voyez installer Haskell avec GHCup et le guide du compilateur GHC, et essayez les exemples en direct dans GHCi.

FAQ

Qu’est-ce qu’une monade en termes simples ? Un type qui vous laisse chaîner des calculs portant un contexte (échec, effets, résultats multiples), en propageant ce contexte automatiquement via l’opérateur bind.

IO est-elle une monade ? Oui — IO est la monade que Haskell utilise pour séquencer les effets de bord tout en restant pur. Votre main s’exécute dedans.

Faut-il comprendre la théorie des catégories ? Non. Vous pouvez utiliser les monades de façon productive en Haskell en ne connaissant que return, >>= et la do-notation ; la théorie est optionnelle.

Quelle est la différence entre Maybe et Either ? Les deux modélisent un échec possible ; Maybe dit juste « absent » (Nothing), tandis que Either porte une valeur d’erreur expliquant l’échec.