एक पुराने प्रश्न की तरह लेकिन यह वास्तव में अच्छा है, इसलिए मैं जवाब दूंगा।
आप कोड के ब्लॉक के रूप में भिक्षुओं के बारे में सोच सकते हैं, जिसके लिए आपका पूरा नियंत्रण है कि उन्हें कैसे निष्पादित किया जाता है: कोड की प्रत्येक पंक्ति को क्या लौटना चाहिए, क्या निष्पादन किसी भी बिंदु पर रुकना चाहिए, क्या प्रत्येक पंक्ति के बीच कुछ अन्य प्रसंस्करण होना चाहिए।
मैं उन चीजों के कुछ उदाहरण दूंगा जो कि भिक्षुओं को सक्षम बनाती हैं अन्यथा मुश्किल होगा। इन उदाहरणों में से कोई भी हास्केल में नहीं है, सिर्फ इसलिए कि मेरा हास्केल ज्ञान थोड़ा अस्थिर है, लेकिन वे सभी उदाहरण हैं कि हास्केल ने भिक्षुओं के उपयोग को कैसे प्रेरित किया है।
पारसर्स
आम तौर पर, यदि आप किसी प्रकार का पार्सर लिखना चाहते हैं, तो प्रोग्रामिंग भाषा को लागू करने के लिए कहें, आपको या तो बीएनएफ विनिर्देश को पढ़ना होगा और इसे पार्स करने के लिए लूप कोड का एक पूरा गुच्छा लिखना होगा, या आपको एक कंपाइलर कंपाइलर का उपयोग करना होगा जैसे फ्लेक्स, बाइसन, याक आदि। लेकिन मोनाड्स के साथ, आप हास्केल में एक प्रकार का "कंपाइलर पार्सर" बना सकते हैं।
पार्सर्स वास्तव में या तो मोनड्स या विशेष-प्रयोजन भाषाओं जैसे कि याक, बाइसन आदि के बिना नहीं किया जा सकता है।
उदाहरण के लिए, मैंने IRC प्रोटोकॉल के लिए BNF भाषा विनिर्देश लिया :
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"
और इसे F # में कोड की लगभग 40 पंक्तियों तक घटा दिया (जो एक और भाषा है जो भिक्षुओं का समर्थन करती है)
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 # का मोनाड सिंटैक्स हास्केल की तुलना में काफी बदसूरत है, और मैं संभवतः इसे थोड़ा सुधार सकता था - लेकिन घर ले जाने की बात यह है कि संरचनात्मक रूप से, पार्सर कोड बीएनएफ के समान है। इतना ही नहीं इसने बिना मोनाड्स (या पार्सर जनरेटर) के बहुत अधिक काम लिया होगा, यह विनिर्देशन के लगभग कोई समानता नहीं थी, और इस तरह दोनों को पढ़ने और बनाए रखने के लिए भयानक था।
कस्टम मल्टीटास्किंग
आम तौर पर, मल्टीटास्किंग को ओएस फीचर के रूप में माना जाता है - लेकिन मोनाड्स के साथ, आप अपने खुद के शेड्यूलर को लिख सकते हैं जैसे कि प्रत्येक निर्देश मोनड के बाद, प्रोग्राम शेड्यूलर पर नियंत्रण पारित करेगा, जो फिर निष्पादित करने के लिए एक और सनक का चयन करेगा।
एक व्यक्ति ने गेम लूप्स (फिर एफ # में) को नियंत्रित करने के लिए एक "कार्य" मोनाड बनाया , ताकि प्रत्येक मशीन पर काम करने वाली एक राज्य मशीन के रूप में सब कुछ लिखने के बजाय 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 वास्तव में एक सन्यासी का उदाहरण है, और इसी तरह की कार्यक्षमता हास्केल में आसानी से लागू की जा सकती है।
जब से मुझे वह सब याद नहीं आया, मैं विवरण में नहीं आऊंगा , लेकिन एरिक मीजर ने इसे अच्छी तरह समझाया है ।