Вроде старый вопрос, но он действительно хороший, поэтому я отвечу.
Вы можете думать о монадах как о блоках кода, для которых у вас есть полный контроль над тем, как они выполняются: что должна возвращать каждая строка кода, должно ли выполнение останавливаться в любой точке, должна ли происходить какая-то другая обработка между каждой строкой.
Я приведу несколько примеров того, что делают монады, что было бы трудно в противном случае. Ни один из этих примеров не написан на 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 # довольно безобразен по сравнению с синтаксисом в Haskell, и я, вероятно, мог бы немного его улучшить, но главное - структурно, код синтаксического анализатора идентичен 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 to SQL
LINQ to SQL на самом деле является примером монады, и аналогичные функциональные возможности могут быть легко реализованы в Haskell.
Я не буду вдаваться в подробности, так как не все точно помню, но Эрик Мейер объясняет это довольно хорошо .