Eski bir soru ama gerçekten iyi bir soru, bu yüzden cevaplayacağım.
Monadları, nasıl yürütüldükleri üzerinde tam kontrole sahip olduğunuz kod blokları olarak düşünebilirsiniz: her bir kod satırının ne dönmesi gerektiği, yürütmenin herhangi bir noktada durması gerekip gerekmediği, her satır arasında başka bir işlem olup olmayacağı.
Monad'ların başka türlü zor olmasını sağlayan şeylere örnekler vereceğim. Bu örneklerin hiçbiri Haskell'de değil, çünkü Haskell bilgim biraz titrek, ama hepsi Haskell'in monadların kullanımına nasıl ilham verdiğinin örnekleri.
ayrıştırıcılar
Normalde, bir programlama dili uygulamak gibi bir tür ayrıştırıcı yazmak istiyorsanız, ya BNF belirtimini okumak ve ayrıştırmak için bir sürü döngüsel kod yazmak zorunda kalacaksınız ya da bir derleyici derleyici kullanmak zorunda kalacaksınız. Flex, Bison, yacc vb. gibi. Ama monad'larla Haskell'de bir çeşit "derleyici ayrıştırıcı" yapabilirsiniz.
Ayrıştırıcılar, monadlar veya yacc, bizon gibi özel amaçlı diller olmadan gerçekten yapılamaz.
Örneğin, IRC protokolü için BNF dil belirtimini aldım :
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"
Ve F #'da (monad'ları destekleyen başka bir dil) yaklaşık 40 kod satırına kadar kırdı:
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 # 'ın monad sözdizimi Haskell ile karşılaştırıldığında oldukça çirkin ve muhtemelen bunu biraz geliştirebilirdim - ama eve götürmenin asıl amacı, ayrıştırıcı kodunun BNF ile aynı olmasıdır. Bu sadece monadlar (veya bir ayrıştırıcı jeneratör) olmadan çok daha fazla çalışma yapmakla kalmaz, aynı zamanda spesifikasyona neredeyse hiç benzemezdi ve bu nedenle hem okumak hem de korumak korkunç olurdu.
Özel çoklu görev
Normalde, çoklu görevin bir işletim sistemi özelliği olduğu düşünülür - ancak monad'larla, her bir talimat monadından sonra programın zamanlayıcıya kontrolü aktaracağı ve daha sonra yürütülecek başka bir monad seçeceği şekilde kendi zamanlayıcınızı yazabilirsiniz.
Bir adam oyun döngülerini kontrol etmek için bir "görev" monad yaptı (yine F #'da), böylece her şeyi her biri üzerinde hareket eden bir devlet makinesi olarak yazmak yerineUpdate() çağrıda tüm talimatları tek bir işlevmiş gibi yazabiliyordu. .
Başka bir deyişle, şöyle bir şey yapmak yerine:
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;
}
}
}
Şöyle bir şey yapabilirsiniz:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
SQL'den LINQ
LINQ to SQL aslında bir monad örneğidir ve Haskell'de benzer işlevler kolayca uygulanabilir.
Tüm bunları tam olarak hatırlamadığım için ayrıntılara girmeyeceğim, ancak Erik Meijer bunu oldukça iyi açıklıyor .