To trochę stare pytanie, ale jest naprawdę dobre, więc odpowiem.
Możesz myśleć o monadach jak o blokach kodu, dla których masz pełną kontrolę nad tym, jak są wykonywane: co zwraca każdy wiersz kodu, czy wykonanie powinno się zatrzymać w dowolnym momencie, czy jakieś inne przetwarzanie powinno nastąpić między poszczególnymi wierszami.
Podam kilka przykładów rzeczy, które umożliwiają monady, które inaczej byłyby trudne. Żaden z tych przykładów nie jest w Haskell, tylko dlatego, że moja wiedza na temat Haskell jest nieco niepewna, ale wszystkie są przykładami tego, jak Haskell zainspirował użycie monad.
Parsery
Zwykle, jeśli chcesz napisać jakiś parser, powiedzmy zaimplementować język programowania, musiałbyś albo przeczytać specyfikację BNF i napisać całą masę pętlowego kodu, aby ją przeanalizować, lub musiałbyś użyć kompilatora kompilatora takich jak Flex, Bison, yacc itp. Ale dzięki monadom możesz stworzyć rodzaj „parsera kompilatora” bezpośrednio w Haskell.
Parserów nie da się tak naprawdę zrobić bez monad ani języków specjalnych, takich jak yacc, bizon itp.
Na przykład wziąłem specyfikację języka BNF dla protokołu 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"
I zmniejszyłem go do około 40 linii kodu w F # (który jest innym językiem obsługującym monady):
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 }
}
Składnia monady F # jest dość brzydka w porównaniu do składni Haskella, i prawdopodobnie mógłbym to nieco poprawić - ale chodzi o to, że strukturalnie kod parsera jest identyczny z BNF. Nie tylko wymagałoby to dużo więcej pracy bez monad (lub generatora analizatora składni), ale prawie nie przypominało specyfikacji, a zatem było okropnie zarówno czytać, jak i utrzymywać.
Niestandardowa wielozadaniowość
Zwykle wielozadaniowość jest uważana za funkcję systemu operacyjnego - ale w przypadku monad można napisać własny harmonogram tak, aby po każdej monadzie instrukcji program przekazał kontrolę harmonogramowi, który następnie wybrałby inną monadę do wykonania.
Jeden facet stworzył monadę „zadaniową” do kontrolowania pętli gry (ponownie w F #), aby zamiast pisać wszystko jako maszynę stanu działającą przy każdym Update()wywołaniu, mógł po prostu napisać wszystkie instrukcje, jakby były pojedynczą funkcją .
Innymi słowy, zamiast robić coś takiego:
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;
}
}
}
Możesz zrobić coś takiego:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ do SQL
LINQ to SQL jest tak naprawdę przykładem monady, a podobną funkcjonalność można łatwo zaimplementować w Haskell.
Nie będę wdawał się w szczegóły, ponieważ nie pamiętam dokładnie tego wszystkiego, ale Erik Meijer wyjaśnia to całkiem dobrze .