Eine alte Frage, aber eine wirklich gute, also werde ich antworten.
Sie können sich Monaden als Codeblöcke vorstellen, für die Sie die vollständige Kontrolle darüber haben, wie sie ausgeführt werden: Was sollte jede Codezeile zurückgeben, ob die Ausführung an einem beliebigen Punkt gestoppt werden soll, ob zwischen jeder Zeile eine andere Verarbeitung stattfinden soll.
Ich werde einige Beispiele für Dinge geben, die Monaden ermöglichen, die sonst schwierig wären. Keines dieser Beispiele befindet sich in Haskell, nur weil mein Haskell-Wissen etwas wackelig ist, aber sie sind alle Beispiele dafür, wie Haskell die Verwendung von Monaden inspiriert hat.
Parser
Wenn Sie einen Parser schreiben möchten, beispielsweise um eine Programmiersprache zu implementieren, müssen Sie normalerweise entweder die BNF-Spezifikation lesen und eine ganze Reihe von Loop-Code schreiben, um ihn zu analysieren, oder Sie müssen einen Compiler-Compiler verwenden wie Flex, Bison, Yacc usw. Aber mit Monaden können Sie direkt in Haskell eine Art "Compiler-Parser" erstellen.
Parser können nicht wirklich ohne Monaden oder Spezialsprachen wie Yacc, Bison usw. durchgeführt werden.
Zum Beispiel habe ich die BNF-Sprachspezifikation für das IRC-Protokoll übernommen :
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"
Und es in F # (einer anderen Sprache, die Monaden unterstützt) auf ungefähr 40 Codezeilen reduziert:
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 }
}
Die Monadensyntax von F # ist im Vergleich zu der von Haskell ziemlich hässlich, und ich hätte dies wahrscheinlich ein wenig verbessern können - aber der Punkt, den man mit nach Hause nehmen sollte, ist, dass der Parser-Code strukturell mit dem BNF identisch ist. Dies hätte nicht nur viel mehr Arbeit ohne Monaden (oder einen Parser-Generator) gekostet, es hätte auch fast keine Ähnlichkeit mit der Spezifikation gehabt und wäre daher sowohl zu lesen als auch zu warten schrecklich gewesen.
Benutzerdefiniertes Multitasking
Normalerweise wird Multitasking als Betriebssystemfunktion betrachtet. Bei Monaden können Sie jedoch Ihren eigenen Scheduler so schreiben, dass das Programm nach jeder Anweisungsmonade die Kontrolle an den Scheduler übergibt, der dann eine andere auszuführende Monade auswählt.
Ein Typ machte eine "Task" -Monade , um Spielschleifen zu steuern (wieder in F #), so dass er, anstatt alles als Zustandsmaschine schreiben zu müssen, die auf jeden Update()Aufruf reagiert, einfach alle Anweisungen schreiben konnte, als wären sie eine einzelne Funktion .
Mit anderen Worten, anstatt etwas tun zu müssen wie:
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;
}
}
}
Sie könnten so etwas tun wie:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ zu SQL
LINQ to SQL ist eigentlich ein Beispiel für eine Monade, und ähnliche Funktionen könnten leicht in Haskell implementiert werden.
Ich werde nicht auf die Details eingehen, da ich mich nicht so genau erinnere, aber Erik Meijer erklärt es ziemlich gut .