Monade (informatique)

Cet article est une ébauche concernant l’informatique.

Vous pouvez partager vos connaissances en l’améliorant (comment ?) selon les recommandations des projets correspondants.

En théorie des langages fonctionnels typés, une monade est un patron de conception qui combine des éléments de langages fonctionnels avec des méthodologies propres aux langages impératifs. En pratique, les valeurs retournées par des portions de programme (qui peuvent être vus comme des fonctions) sont englobées en un type pour être enchaînées ultérieurement en d'autres calculs. Il s'agit alors d'avoir une représentation simulant exactement des notions telles que les exceptions ou les effets de bords, tout en conservant la logique propre à la programmation fonctionnelle. L'usage des monades présente plusieurs intérêts : analyses statiques et preuves de programmes plus simples, usage de l'appel par nécessité, optimisations (déforestation, mémoïsation de valeurs, parallélisation, réduction forte (en)).

Concepts[modifier | modifier le code]

Définition formelle[modifier | modifier le code]

Une monade peut se voir comme la donnée d'un triplet constitué des trois éléments suivants :

un constructeur de type appelé type monadique, qui associe au type $t$ le type $Mt$ ;
une fonction nommée unit ou return, qui construit à partir d'un élément de type sous-jacent $a$ un autre objet de type monadique $Ma$ . Cette fonction est alors de signature ${\text{return}}:t\rightarrow Mt$ ;
une fonction bind, représentée par l'opérateur infixe $\gg \!=$ , associant à un type monadique et une fonction d'association un autre type monadique. Il permet de composer une fonction monadique à partir d'autres fonctions monadiques. Cet opérateur est de type $\gg \!=:Mt\rightarrow (t\rightarrow Mu)\rightarrow Mu$ .

En composant la fonction $\gg \!=$ (dite fonction de liaison) avec la fonction ${\text{return}}$ , on peut appliquer n'importe quelle fonction $g:t\rightarrow t$ à une monade de type $Mt$ . En ce sens une monade de type $Mt$ est un type algébrique qui dérive du type $t$ .

Axiomes[modifier | modifier le code]

La définition précédente s'accompagne de plusieurs axiomes^[1]. L'opérateur ${\text{return}}$ agit comme une sorte d'élément neutre pour $\gg \!=$ .

composition à gauche par ${\text{return}}$ (≡ désigne l'égalité structurelle) :
$({\text{return}}\;x)\gg \!=f\equiv f\;x$
composition à droite par ${\text{return}}$ :
$m\gg \!={\text{return}}\equiv m$
associativité :
$(m\gg \!=f)\gg \!=g\equiv m\gg \!=\lambda x\;.\;(f\,x\gg \!\!=g)$ (ou $(x\mapsto fx\gg \!=g)$ )

Utilisation[modifier | modifier le code]

L'utilisation la plus simple des monades consiste à encapsuler un objet de type existant dans un objet portant plus d'information. Par exemple en langage Haskell, une monade de type $Maybe(t)$ est ou bien un objet de type t normal, ou bien la valeur $Nothing$ . Cela permet de traiter de façon élégante les opérations interdites.

Une autre utilisation fondamentale des monades est la gestion des entrées/sorties dans un programme purement fonctionnel, c'est-à-dire sans effets de bord. C'est le cas de la monade $IO(t)$ en Haskell, qui représente un programme impératif sans paramètre et renvoyant une valeur de type t. Ainsi getLine est une action de type $IO(String)$ , un programme impératif qui lorsqu'il est exécuté renvoie une chaîne de caractères (celle tapée au clavier). Confirmons qu'un programme impératif renvoyant un $t$ est une monade. À tout objet $o$ de type $t$ on peut associer le programme trivial ${\text{return}}\;o$ qui renvoie toujours $o$ . C'est d'ailleurs l'origine de la notation ${\text{return}}$ pour les types monadiques. Ensuite, étant donné une fonction g:t→t, il est naturel de pouvoir l'appliquer à un programme qui renvoie un t, cela donne un autre programme qui renvoie un t. On peut voir cette opération comme la concaténation du code source du premier programme et du code de la fonction g.

La programmation fonctionnelle contourne ainsi le problème des entrées/sorties (naturellement des effets de bords) par la manipulation de ces programmes impératifs eux-mêmes et non des valeurs qu'ils retournent. Pour se fixer les idées, on peut se dire qu'une monade de type IO(int) est le code C d'un programme renvoyant un entier. Ainsi le type IO(int) est complètement légitime dans le cadre fonctionnel puisque c'est simplement du texte. Lors de la compilation du programme fonctionnel, ces monades seront traduites en code machine qui aura l'effet attendu lorsqu'il sera exécuté.

Voir aussi[modifier | modifier le code]

Notes et références[modifier | modifier le code]

↑ (en) « Monad laws »

Liens externes[modifier | modifier le code]

Si ce bandeau n'est plus pertinent, retirez-le. Cliquez ici pour en savoir plus.

Cet article ou cette section contient trop de liens externes (janvier 2010).

Les liens externes doivent être des sites de référence dans le domaine du sujet. Il est souhaitable — si cela présente un intérêt — de citer ces liens comme source et de les enlever du corps de l'article ou de la section « Liens externes ».

(fr) Les monades dans la programmation fonctionnelle
(en) What the hell are Monads?
(en) You Could Have Invented Monads! (And Maybe You Already Have.)
(en) All About Monads
(en) Monads as Computation
(en) Monads as Containers
(en) Monads for the Working Haskell Programmer
(en) "Monads for Functional Programming" par Philip Wadler
(en) A tour of the Haskell Monad functions par Henk-Jan van Tuyl
(en) The Haskell Programmer's Guide to the IO Monad — Don't Panic
(en) Monads in Ruby
(en) Monads in Python
(en) Notions of Computation and Monads par Eugenio Moggi
(en) Introduction to Haskell, Part 3: Monads

Portail de l’informatique

[1] (en) « Monad laws »

[1]