C'est une vieille question, mais elle est vraiment bonne, alors je vais répondre.
Vous pouvez considérer les monades comme des blocs de code pour lesquels vous avez un contrôle total sur la façon dont ils sont exécutés: ce que chaque ligne de code doit retourner, si l'exécution doit s'arrêter à tout moment, si un autre traitement doit avoir lieu entre chaque ligne.
Je vais donner quelques exemples de choses que les monades permettent et qui seraient difficiles autrement. Aucun de ces exemples n'est en Haskell, juste parce que mes connaissances en Haskell sont un peu chancelantes, mais ce sont tous des exemples de la façon dont Haskell a inspiré l'utilisation des monades.
Analyseurs
Normalement, si vous vouliez écrire un analyseur quelconque, par exemple pour implémenter un langage de programmation, vous devriez soit lire la spécification BNF et écrire tout un tas de code en boucle pour l'analyser, soit utiliser un compilateur compilateur comme Flex, Bison, yacc etc .. Mais avec les monades, vous pouvez faire une sorte de "compilateur analyseur" directement dans Haskell.
Les analyseurs ne peuvent pas vraiment se faire sans monades ni langages spéciaux comme le yacc, le bison, etc.
Par exemple, j'ai pris la spécification du langage BNF pour le protocole IRC :
message = [ ":" prefix SPACE ] command [ params ] crlf
prefix = servername / ( nickname [ [ "!" user ] "@" host ] )
command = 1*letter / 3digit
params = *14( SPACE middle ) [ SPACE ":" trailing ]
=/ 14( SPACE middle ) [ SPACE [ ":" ] trailing ]
nospcrlfcl = %x01-09 / %x0B-0C / %x0E-1F / %x21-39 / %x3B-FF
; any octet except NUL, CR, LF, " " and ":"
middle = nospcrlfcl *( ":" / nospcrlfcl )
trailing = *( ":" / " " / nospcrlfcl )
SPACE = %x20 ; space character
crlf = %x0D %x0A ; "carriage return" "linefeed"
Et je l'ai réduit à environ 40 lignes de code en F # (qui est un autre langage qui prend en charge les monades):
type UserIdentifier = { Name : string; User: string; Host: string }
type Message = { Prefix : UserIdentifier option; Command : string; Params : string list }
let space = character (char 0x20)
let parameters =
let middle = parser {
let! c = sat <| fun c -> c <> ':' && c <> (char 0x20)
let! cs = many <| sat ((<>)(char 0x20))
return (c::cs)
}
let trailing = many item
let parameter = prefixed space ((prefixed (character ':') trailing) +++ middle)
many parameter
let command = atLeastOne letter +++ (count 3 digit)
let prefix = parser {
let! name = many <| sat (fun c -> c <> '!' && c <> '@' && c <> (char 0x20)) //this is more lenient than RFC2812 2.3.1
let! uh = parser {
let! user = maybe <| prefixed (character '!') (many <| sat (fun c -> c <> '@' && c <> (char 0x20)))
let! host = maybe <| prefixed (character '@') (many <| sat ((<>) ' '))
return (user, host)
}
let nullstr = function | Some([]) -> null | Some(s) -> charsString s | _ -> null
return { Name = charsString name; User = nullstr (fst uh); Host = nullstr (snd uh) }
}
let message = parser {
let! p = maybe (parser {
let! _ = character ':'
let! p = prefix
let! _ = space
return p
})
let! c = command
let! ps = parameters
return { Prefix = p; Command = charsString c; Params = List.map charsString ps }
}
La syntaxe monade de F # est assez moche par rapport à celle de Haskell, et j'aurais probablement pu améliorer cela un peu - mais le point à retenir est que structurellement, le code de l'analyseur est identique au BNF. Non seulement cela aurait pris beaucoup plus de travail sans monades (ou générateur de parseurs), mais cela n'aurait eu presque aucune ressemblance avec les spécifications, et aurait donc été terrible à lire et à maintenir.
Multitâche personnalisé
Normalement, le multitâche est considéré comme une fonctionnalité du système d'exploitation - mais avec les monades, vous pouvez écrire votre propre planificateur de telle sorte qu'après chaque monade d'instructions, le programme passe le contrôle au planificateur, qui choisit ensuite une autre monade à exécuter.
Un gars a créé une monade "tâche" pour contrôler les boucles de jeu (encore une fois en F #), de sorte qu'au lieu d'avoir à tout écrire comme une machine d'état qui agit à chaque Update()appel, il pourrait simplement écrire toutes les instructions comme s'il s'agissait d'une seule fonction .
En d'autres termes, au lieu d'avoir à faire quelque chose comme:
class Robot
{
enum State { Walking, Shooting, Stopped }
State state = State.Stopped;
public void Update()
{
switch(state)
{
case State.Stopped:
Walk();
state = State.Walking;
break;
case State.Walking:
if (enemyInSight)
{
Shoot();
state = State.Shooting;
}
break;
}
}
}
Vous pourriez faire quelque chose comme:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ to SQL
LINQ to SQL est en fait un exemple de monade, et des fonctionnalités similaires pourraient facilement être implémentées dans Haskell.
Je n'entrerai pas dans les détails car je ne me souviens pas de tout cela avec précision, mais Erik Meijer l'explique assez bien .