É uma pergunta antiga, mas realmente boa, então eu responderei.
Você pode pensar nas mônadas como blocos de código para os quais você tem controle completo sobre como elas são executadas: o que cada linha de código deve retornar, se a execução deve parar a qualquer momento, se algum outro processamento deve ocorrer entre cada linha.
Vou dar alguns exemplos de coisas que as mônadas permitem que, caso contrário, seriam difíceis. Nenhum desses exemplos está em Haskell, apenas porque meu conhecimento sobre Haskell é um pouco instável, mas todos são exemplos de como Haskell inspirou o uso de mônadas.
Analisadores
Normalmente, se você quiser escrever um analisador de algum tipo, digamos, para implementar uma linguagem de programação, você precisará ler a especificação BNF e escrever um monte de código em loop para analisá-lo ou usar um compilador de compilador como Flex, Bison, yacc etc. Mas com mônadas, você pode criar um tipo de "analisador de compilador" direto no Haskell.
Analisadores não podem realmente ser feitos sem mônadas ou linguagens para fins especiais, como yacc, bison etc.
Por exemplo, peguei a especificação da linguagem BNF para o protocolo 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 reduziu para cerca de 40 linhas de código em F # (que é outra linguagem que suporta mônadas):
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 }
}
A sintaxe da mônada do F # é bastante feia comparada à de Haskell, e eu provavelmente poderia ter melhorado bastante isso - mas o ponto a ser levado para casa é que, estruturalmente, o código do analisador é idêntico ao BNF. Isso não apenas teria exigido muito mais trabalho sem mônadas (ou um gerador de analisador), como não teria quase nenhuma semelhança com a especificação e, portanto, seria terrível de ler e manter.
Multitarefa personalizada
Normalmente, a multitarefa é considerada um recurso do sistema operacional - mas com mônadas, você pode escrever seu próprio agendador de forma que, após cada mônada de instruções, o programa passe o controle para o agendador, que escolheria outra mônada para executar.
Um cara fez uma mônada de "tarefa" para controlar os loops de jogo (novamente em F #), para que, em vez de escrever tudo como uma máquina de estado que atua em cada Update()chamada, ele pudesse escrever todas as instruções como se fossem uma única função .
Em outras palavras, em vez de ter que fazer algo como:
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;
}
}
}
Você poderia fazer algo como:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ para SQL
LINQ to SQL é realmente um exemplo de mônada, e funcionalidades semelhantes podem ser facilmente implementadas no Haskell.
Não vou entrar em detalhes, já que não me lembro de tudo com precisão, mas Erik Meijer explica isso muito bem .