Es una pregunta vieja, pero es muy buena, así que responderé.
Puede pensar en las mónadas como bloques de código para los que tiene un control completo sobre cómo se ejecutan: qué debe devolver cada línea de código, si la ejecución debe detenerse en algún momento, si debe ocurrir algún otro procesamiento entre cada línea.
Daré algunos ejemplos de cosas que las mónadas permiten que de otra forma serían difíciles. Ninguno de estos ejemplos está en Haskell, solo porque mi conocimiento de Haskell es un poco inestable, pero todos son ejemplos de cómo Haskell ha inspirado el uso de mónadas.
Analizadores
Normalmente, si quisiera escribir un analizador de algún tipo, por ejemplo, para implementar un lenguaje de programación, tendría que leer la especificación BNF y escribir un montón de código de bucle para analizarlo, o tendría que usar un compilador de compilador como Flex, Bison, yacc, etc. Pero con las mónadas, puedes hacer una especie de "analizador de compiladores" directamente en Haskell.
Los analizadores realmente no se pueden hacer sin mónadas o lenguajes especiales como yacc, bison, etc.
Por ejemplo, tomé la especificación del lenguaje BNF para el 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"
Y lo redujo a aproximadamente 40 líneas de código en F # (que es otro lenguaje que admite 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 }
}
La sintaxis de mónada de F # es bastante fea en comparación con la de Haskell, y probablemente podría haber mejorado esto bastante, pero el punto a tener en cuenta es que, estructuralmente, el código del analizador es idéntico al BNF. Esto no solo habría llevado mucho más trabajo sin mónadas (o un generador de analizadores sintácticos), sino que habría tenido casi ninguna semejanza con la especificación y, por lo tanto, habría sido terrible tanto para leer como para mantener.
Multitarea personalizada
Normalmente, se considera que la multitarea es una característica del sistema operativo, pero con las mónadas, puede escribir su propio planificador de modo que después de cada mónada de instrucciones, el programa pasaría el control al planificador, que luego elegiría otra mónada para ejecutar.
Un tipo hizo una mónada de "tarea" para controlar los bucles del juego (nuevamente en F #), de modo que en lugar de tener que escribir todo como una máquina de estado que actúa en cada Update()llamada, podría escribir todas las instrucciones como si fueran una sola función .
En otras palabras, en lugar de tener que hacer 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;
}
}
}
Podrías hacer algo como:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ to SQL
LINQ to SQL es en realidad un ejemplo de una mónada, y una funcionalidad similar podría implementarse fácilmente en Haskell.
No entraré en detalles ya que no recuerdo con tanta precisión, pero Erik Meijer lo explica muy bien .