Agak pertanyaan lama tapi itu benar-benar bagus, jadi saya akan jawab.
Anda dapat menganggap monads sebagai blok kode yang Anda miliki kendali penuh atas cara mereka dieksekusi: apa yang harus dikembalikan setiap baris kode, apakah eksekusi harus berhenti pada titik mana pun, apakah beberapa pemrosesan lain harus terjadi di antara setiap baris.
Saya akan memberikan beberapa contoh hal-hal yang dimungkinkan oleh monad yang akan sulit sebaliknya. Tak satu pun dari contoh-contoh ini ada di Haskell, hanya karena pengetahuan Haskell saya agak goyah, tetapi mereka semua adalah contoh bagaimana Haskell mengilhami penggunaan monad.
Parser
Biasanya, jika Anda ingin menulis semacam parser, katakanlah untuk mengimplementasikan bahasa pemrograman, Anda harus membaca spesifikasi BNF dan menulis sejumlah besar kode gila untuk menguraikannya, atau Anda harus menggunakan kompiler kompiler seperti Flex, Bison, yacc dll. Tetapi dengan monads, Anda dapat membuat semacam "kompiler parser" tepat di Haskell.
Parser tidak dapat dilakukan tanpa monad atau bahasa tujuan khusus seperti yacc, bison dll.
Misalnya, saya mengambil spesifikasi bahasa BNF untuk protokol 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"
Dan mengubahnya menjadi sekitar 40 baris kode dalam F # (yang merupakan bahasa lain yang mendukung monads):
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 }
}
Sintaks monad F # sangat jelek dibandingkan dengan Haskell, dan saya mungkin bisa sedikit memperbaiki ini - tetapi intinya untuk dibawa pulang adalah secara struktural, kode parser identik dengan BNF. Tidak hanya ini akan membutuhkan lebih banyak pekerjaan tanpa monad (atau generator parser), itu akan hampir tidak memiliki kemiripan dengan spesifikasi, dan dengan demikian mengerikan untuk dibaca dan dipelihara.
Multitasking khusus
Biasanya, multitasking dianggap sebagai fitur OS - tetapi dengan monads, Anda dapat menulis penjadwal Anda sendiri sehingga setelah setiap instruksi monad, program akan memberikan kontrol ke penjadwal, yang kemudian akan memilih monad lain untuk dieksekusi.
Seorang pria membuat monad "tugas" untuk mengontrol loop game (sekali lagi dalam F #), sehingga daripada harus menulis semuanya sebagai mesin negara yang bekerja pada setiap Update()panggilan, ia hanya dapat menulis semua instruksi seolah-olah itu adalah fungsi tunggal .
Dengan kata lain, alih-alih harus melakukan sesuatu seperti:
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;
}
}
}
Anda dapat melakukan sesuatu seperti:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ ke SQL
LINQ to SQL sebenarnya adalah contoh dari monad, dan fungsi serupa dapat dengan mudah diimplementasikan di Haskell.
Saya tidak akan membahas detailnya karena saya tidak mengingat semua itu dengan akurat, tetapi Erik Meijer menjelaskannya dengan cukup baik .