Вигляд старого питання, але він справді хороший, тому я відповім.
Ви можете розглядати монади як блоки коду, за якими ви маєте повний контроль над тим, як вони виконуються: що повинен повертати кожен рядок коду, чи слід зупиняти виконання в будь-якій точці, чи повинна відбуватися якась інша обробка між кожним рядком.
Я наведу кілька прикладів того, що монади дозволяють, що в іншому випадку буде важко. Жоден із цих прикладів не є в Haskell, тільки тому, що мої знання Haskell трохи хиткі, але вони всі приклади того, як Haskell надихнув на використання монад.
Парсери
Зазвичай, якщо ви хотіли написати якийсь аналізатор, скажімо, реалізувати мову програмування, вам доведеться або прочитати специфікацію BNF і написати цілу купу кодового коду, щоб розібрати його, або вам доведеться використовувати компілятор-компілятор як Flex, Bison, yacc тощо. Але з монадами ви можете зробити своєрідний "аналізатор компілятора" прямо в Haskell.
Парсери справді не обійтися без монад чи мов спеціального призначення, таких як yacc, bison тощо.
Наприклад, я взяв специфікацію мови BNF для протоколу 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"
І скоротив його приблизно до 40 рядків коду у F # (це ще одна мова, яка підтримує монади):
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 }
}
Синтаксис монади F # є досить потворним порівняно з Хаскеллом, і я, швидше за все, міг би покращити це - але сенс взяти додому те, що структурно код парсера ідентичний BNF. Мало того, що це зайняло б набагато більше роботи без монад (або генератора аналізаторів), воно мало б майже не схоже на специфікацію, і, таким чином, було б страшно і читати, і підтримувати.
Спеціальна багатозадачність
Зазвичай багатозадачність вважається функцією ОС, але за допомогою монад ви можете написати власний планувальник таким чином, щоб після кожної монади інструкцій програма передавала контроль планувальнику, який вибирав би іншу монаду для виконання.
Один хлопець склав монаду "завдання" контролювати ігрові петлі (знову ж у F #), так що замість того, щоб писати все як державна машина, яка діє на кожен Update()дзвінок, він міг просто написати всі вказівки так, ніби вони були однією функцією .
Іншими словами, замість того, щоб робити щось на кшталт:
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;
}
}
}
Ви можете зробити щось на кшталт:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ в SQL
LINQ to SQL насправді є прикладом монади, і подібний функціонал може бути легко реалізований в Haskell.
Я не буду вникати в деталі, оскільки не пам'ятаю все так точно, але Ерік Мейєр це досить добре пояснює .