Présentation sommaire des monades

Cet article se veut une présentation extrêmement rapide du concept de monade, en précisant les points clés et l'intérêt du point de vue informatique. Les concepts mathématiques nécessaire à la compréhension ont été réduits au minimum.

Nous considérons dans un premier temps l'ensemble des fonctions F : A -> A qui est vu comme un monoïde. Il est possible d'enrichir, grâce à un constructeur de type M, le résultat de la fonction pour assurer par exemple : gestion des erreurs, IO, exception, transaction, ...). Nous obtenons un nouvel ensemble FM : A -> M A. Lorsque M est une monade, la combinaison de deux fonctions quelconques de FM par l'opérateur bind (>>=) de la monade est une fonction de FM. Le développement monadique est extrêmement utilisé dans les librairies et frameworks fonctionnels car il permet d'en simplifier l'appropriation par le développeur.

Parlons fonction

Considérons la fonction identité qui pour tout entier n renvoi l'entier n :
f : N -> N définie par f(n) = n, ∀ n ∈ N

En notation Scala, cela donnerait :
def f(n : Int) = n

Enrichir le résultat d'une fonction

Pour de nombreuses raisons il peut être utile d'enrichir le résultat d'une fonction, par exemple :

savoir si la fonction s'est bien executée, le résultat est-il correct ou s'agit il d'une erreur ?
renvoyer un message à afficher à l'utilisateur en même temps que le résultat
mémoriser un état sans utiliser de variable mutable externe à la fonction
gérer un contexte transactionnel
...

Un type générique T permet d'utiliser notre Resultat quel que soit le type de retour de la fonction. Considérons la structure de type Resultat[T] qui peut :

soit être un Succes et contenir la valeur de retour de la fonction
soit être une Erreur

Voici un exemple (simplifié) de la structure de Resultat[T] que nous appelons M[T] dans la définition scala suivante :

abstract class M[T]
case class Succes[T](a : T) extends M[T]
case class Error[T] extends M[T]

Utiliser une structure intermédiaire permet d'enrichir le résultat de la fonction. Réécrivons notre fonction identité :
def identite( n : Int ) : Resultat[Int] = Succes(n)

Notion de Monoide

Un monoide est un ensemble E doté d'une fonction * et d'un élément neutre e tel que :

∀(x,y)∈ (E, E) , x*y ∈ E (stabilité)
∀(x,y,z) ∈ (E, E, E), x*(y*z) = (x*y)*z (associativité)
il existe e qui appartient à E, et pour tout x qui appartient à E, x*e=e*x=x (existence d'un élément neutre)

Considérons l'ensemble F des fonctions f tel que f : a -> a .

Nous utilisons içi la notation Haskel plus simple f: a -> a
- qui correspond en scala au type
- type Func[T] = T => T (en scala)
La fonction composition ° est définie de la manière suivante :
- def °[T](f : Func[T], g : Func[T]) = (x : T) => f(g(x))
L'élément id est définie de la manière suivante :
- def id[T] : Func[T] = (a : T) => a

L'ensemble F doté de la fonction composition ° et de l'élément id c'est à dire (F, °, id) est un monoide. Ce résultat implique que quelle que soit la manière de combiner les fonctions de l'ensemble F à l'aide de l'opérateur °, on obtient toujours une fonction de l'ensemble F.

Notion de Monade

Remarque : La présente section ne prétend être ni exacte ni complète d'un point de vue mathématique ou informatique, l'objectif est que le lecteur puisse y trouver quelques clés de compréhension.

Nous avons vu que l'ensemble F : a -> a est un monoide.
Lorsque l'on enrichi le résultat d'un fonction avec un constructeur de type M, que se passe-t-il dans l'espace des fonctions FM: a -> M[a] ?

L'objectif est de trouver une structure proche du monoide F, afin de pouvoir combiner les fonctions de l'espace FM de la même manière que l'opérateur ° permet de combiner les fonctions dans l'espace F.

Remarque : dans ce nouvel espace de fonctions FM, l'opérateur de combinaison s'appelle bind et est noté >>= par la communauté Haskell.

La monade est un triplet (M, return, >>=) tel que :

M est le contructeur de type associé au type T, comme dans le cas précédant avec la hierarchie Resultat[T]
return est la fonction qui permet de créer à partir d'une instance d'object de type T l'objet conteneur correspondant
- par exemple : def return (a : T) : Resultat[T] = Succes(a)
bind est l'opérateur qui permet de composer les fonctions de l'espace FM

Voici un exemple d'utilisation de la monade (M, return, >>=) :

soit la fonction verifierParametre qui permet de vérifer qu'un paramètre est valide
- def verifierParametre(i : Int) : M[Int]
soit la fonction effectuerCalcul qui permet d'effectuer un calcul
- def effectuerCalcul(i : Int) : M[Int]
on cherche à écrire la fonction calculGlobal qui permet de vérifier les paramètres puis d'effectuer le calcul
- en utilisant l'opérateur >>= qui est utilisé en Haskell la définition de calculGlobal est
- calculGlobal = verifierParameter >>= effectuerCalcul

Le language Scala (tout comme les autres languages fonctionnels tels qu'Haskell ou F#) proposent une notation appelé comprehension for qui permet d'exprimer de manière très simple la composition de fonction.
En scala la définition de la fonction calculGlobal est :

def calculGlobal(x: Int) = for (p <- verifierParametre(x); r <- effectuerCalcul(p)) yield r

Utiliser la monade Resultat[T] nous permet içi d'être certain que la nouvelle fonction calculGlobal est bien une fonction qui prend un Int en paramètre et renvoi un Resultat[T].

La monade permet de décomposer le traitement en fonctions indépendante et immutables :

les fonctions sont beaucoup plus faciles à developper et contiennent intrinsèquement beaucoup moins de bug
l'immutabilité permet de faciliter grandement les tests, ceux-ci sont plus faciles à réaliser

Un langage comme scala propose de nombreux constructeurs de type (Option, List, Set, ...) qui sont implémentés comme des monades et permettent donc la composition de fonction. Le style utilisé pour rédigé les programme est alors beaucoup plus fluide et lisible.

La monade est un outil. Un développeur scala débutant n'a pas besoin d'écrire de monade, il utilise celles-ci via la "comprehension for".

Pourquoi chercher à comprendre alors ?

Lorsque l'on développe une librairie et que l'on crée de nouveaux constructeurs de type il est essentiel d'en faciliter l'usage pour les utilisateur de la libraire. Permettre à l'utilisateur final de la librairie d'utilise la comprehension for donne une API beaucoup plus puissante et simple à mettre en oeuvre.

Lorsqu'on effectue un développement monadique :

la notion de monade est indépendante du langage, il est par contre impératif de disposer au moins de fonction lambda
la compréhension for de scala ne s'appuie pas sur le triplet (M, return, >>=) d'Haskell, mais sur les méthodes map, flatMap et la conversion Monade M <=> Iterable
- il est intéressant dans ce cas d'hériter de Product (voir le code source du type Option)
- la fonction flatMap de scala est l'équivalent de la fonction >>= d'Haskell
- la fonction return est souvent implémentée par une fonction def apply(..) : M soit dans le constructeur du sous type considéré, soit dans l'objet compagnon
placer un résultat de calcul dans une monade s'est bien, utiliser le résultat c'est mieux :
- la fonction def get : T est souvent utilisée pour extraire le résultat
- on lui préfère cependant un pattern matching qui est beaucoup plus sur car il permet de gérer les cas d'erreur lorsque la fonction get ne peut pas renvoyer de résultat

Voici quelques exemple de type monadiques* :

Type	Framework	Commentaire
List, Set	scala	L'API Collection de scala est extrêmement élaborée, la notion de monade conjuguée avec la compréhension for permet d'effectuer facilement de nombreux traitements, nombreux sont les impatients qui veulent mettre à l'épreuve les futures ParallelCollections.
Box	Liftweb	Le type Box de lift peut être vu comme une variante du Either[T, Exception], ce type propose de nombreux raccourci d'écriture. Il me parait essentiel d'utiliser Box (ou un équivalent) lorsque l'on écrit une API. Mettre en exergue la validité (ou non) des paramètres permet de se poser les nonnes question et détecter au plus tôt la majorité des cas d'erreurs.
Transaction	Akka	Depuis 2009 le type Transaction d'akka est monadique, voir http://groups.google.com/group/akka-user/browse_thread/thread/790c9c1b4c00ec8d pour plus d'information.

(*) on peut traduire en première approximation type monadique par type qu'il est possible d'utiliser au sein d'une compréhension for.