เป็นคำถามแบบเก่า แต่เป็นคำถามที่ดีจริงๆดังนั้นฉันจะตอบ
คุณสามารถคิดว่า monads เป็นกลุ่มของรหัสที่คุณสามารถควบคุมการใช้งานได้อย่างสมบูรณ์: สิ่งที่แต่ละบรรทัดของโค้ดควรกลับมาไม่ว่าการดำเนินการควรจะหยุดที่จุดใด ๆ ไม่ว่าการประมวลผลอื่น ๆ ควรเกิดขึ้นระหว่างแต่ละบรรทัด
ฉันจะให้ตัวอย่างของสิ่งที่พระเปิดใช้งานซึ่งอาจเป็นเรื่องยาก ไม่มีตัวอย่างเหล่านี้อยู่ใน Haskell เพียงเพราะความรู้ของ Haskell ของฉันสั่นเล็กน้อย แต่พวกเขาทั้งหมดเป็นตัวอย่างของ Haskell ที่เป็นแรงบันดาลใจให้ใช้ monads
parsers
โดยปกติถ้าคุณต้องการเขียนโปรแกรมแยกวิเคราะห์บางส่วนเพื่อใช้ภาษาการเขียนโปรแกรมคุณจะต้องอ่านข้อกำหนดของ BNFและเขียนรหัส loopy ทั้งกลุ่มเพื่อแยกวิเคราะห์หรือคุณต้องใช้คอมไพเลอร์คอมไพเลอร์เช่น Flex, Bison, yacc เป็นต้น แต่ด้วย monads คุณสามารถสร้าง "compars parser" ใน 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 }
}
ไวยากรณ์ของ monad ของ F # นั้นค่อนข้างน่าเกลียดเมื่อเทียบกับ Haskell และฉันน่าจะได้รับการปรับปรุงให้ดีขึ้นเล็กน้อย - แต่จุดที่จะกลับบ้านก็คือโครงสร้างรหัส parser นั้นเหมือนกับ BNF สิ่งนี้ไม่เพียง แต่จะทำงานได้มากขึ้นโดยไม่ต้อง monads (หรือตัวแยกวิเคราะห์) มันก็แทบจะไม่มีความคล้ายคลึงกับสเปคและมันก็แย่มากทั้งในการอ่านและการบำรุงรักษา
มัลติทาสกิ้งที่กำหนดเอง
โดยปกติแล้วมัลติทาสกิ้งคิดว่าเป็นคุณลักษณะของระบบปฏิบัติการ - แต่ด้วย monads คุณสามารถเขียนกำหนดการของคุณเองซึ่งหลังจากแต่ละคำสั่ง monad โปรแกรมจะผ่านการควบคุมไปยังตัวกำหนดตารางเวลาซึ่งจะเลือก monad อื่นเพื่อดำเนินการ
ผู้ชายคนหนึ่งทำ"งาน" monadเพื่อควบคุมลูปเกม (อีกครั้งใน 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 เป็นตัวอย่างของ monad และฟังก์ชันการทำงานที่คล้ายกันสามารถนำมาใช้ใน Haskell ได้อย่างง่ายดาย
ฉันจะไม่ได้ลงรายละเอียดตั้งแต่ผมจำไม่ได้ว่าทุกสิ่งที่ถูกต้อง แต่เอริคเมย์เยอร์อธิบายได้ค่อนข้างดี