Una specie di vecchia domanda, ma è davvero una buona domanda, quindi risponderò.
Puoi pensare alle monadi come blocchi di codice per i quali hai il controllo completo su come vengono eseguiti: cosa dovrebbe restituire ogni riga di codice, se l'esecuzione dovrebbe fermarsi in qualsiasi momento, se qualche altra elaborazione dovrebbe avvenire tra ciascuna riga.
Darò alcuni esempi di cose che le monadi consentono che altrimenti sarebbe difficile. Nessuno di questi esempi è in Haskell, solo perché la mia conoscenza di Haskell è un po 'traballante, ma sono tutti esempi di come Haskell abbia ispirato l'uso delle monadi.
parser
Normalmente, se volessi scrivere un parser di qualche tipo, dire di implementare un linguaggio di programmazione, dovresti leggere la specifica BNF e scrivere un sacco di codice loopy per analizzarlo, o dovresti usare un compilatore del compilatore come Flex, Bison, Yacc ecc. Ma con le monadi, puoi creare una specie di "compilatore di compilatori" proprio in Haskell.
I parser non possono davvero essere fatti senza monadi o linguaggi speciali come yacc, bisonte ecc.
Ad esempio, ho preso la specifica del linguaggio BNF per il protocollo 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"
E lo ho ridotto a circa 40 righe di codice in F # (che è un'altra lingua che supporta le monadi):
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 sintassi della monade di F # è piuttosto brutta rispetto a quella di Haskell e probabilmente avrei potuto migliorarlo un po ', ma il punto da portare a casa è che strutturalmente, il codice parser è identico al BNF. Non solo questo avrebbe richiesto molto più lavoro senza le monadi (o un generatore di parser), ma non avrebbe avuto quasi nessuna somiglianza con le specifiche, e quindi sarebbe stato terribile sia da leggere che da mantenere.
Multitasking personalizzato
Normalmente, il multitasking è pensato come una funzionalità del sistema operativo - ma con le monadi, è possibile scrivere il proprio scheduler in modo tale che dopo ogni monade delle istruzioni, il programma passerebbe il controllo allo scheduler, che quindi sceglierebbe un'altra monade da eseguire.
Un ragazzo ha creato una monade "compito" per controllare i loop di gioco (sempre in F #), in modo che invece di dover scrivere tutto come una macchina a stati che agisca su ogni Update()chiamata, potrebbe semplicemente scrivere tutte le istruzioni come se fossero un'unica funzione .
In altre parole, invece di dover fare qualcosa del genere:
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;
}
}
}
Potresti fare qualcosa del tipo:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ to SQL
LINQ to SQL è in realtà un esempio di monade e funzionalità simili potrebbero essere facilmente implementate in Haskell.
Non entrerò nei dettagli poiché non ricordo tutto così accuratamente, ma Erik Meijer lo spiega abbastanza bene .