हास्केल क्वेस्ट ट्यूटोरियल - हॉल

सबसे अधिक संभावना है, यह समय पर प्रकाशित अंतिम भाग है। मेरी छुट्टी लगभग खत्म हो गई है, और अब एक सप्ताह एक लेख लिखना बहुत मुश्किल होगा। सभी के लिए धन्यवाद जो हास्केल क्वेस्ट ट्यूटोरियल में रुचि रखते थे!

लिविंग रूम
आप लिविंग रूम में हैं। पूर्व की ओर एक द्वार है, पश्चिम में अजीब गॉथिक के साथ एक लकड़ी का दरवाजा है, जो नेल बंद, एक ट्रॉफी का मामला है, और कमरे के केंद्र में एक बड़े प्राच्य गलीचा दिखाई देता है।
ट्रॉफी मामले के ऊपर महान पुरातनता की एक एल्विश तलवार लटकी हुई है।
एक बैटरी चालित पीतल लालटेन ट्रॉफी के मामले में है।

सामग्री:
ग्रीटिंग
भाग 1 - आगे
भाग 2 - वन
भाग 3 - पोलीना
भाग 4 - घाटी का दृश्य
भाग 5 - हॉल

भाग 5
जिसमें हम एक छोटी सी त्रुटि से महत्वपूर्ण परिणाम प्राप्त करेंगे, और फिर खेल में वस्तुओं को जोड़ देंगे।


सबसे पहले, हमारी स्मृति को ताज़ा करें। चलिए चलते हैं फंक्शन पर, जो हमें चौथे भाग में मिला। जैसा कि आप देख सकते हैं, मैंने आपके लिए काम किया, लुक एक्शन जोड़ा। रन फ़ंक्शन अब प्रभावशाली दिखता है:

दौड़ना curLoc = करना
putStrLn ( वर्णन कर्लोक )
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
छोड़ो -> putStrLn " तुमको देखा ..."
देखो -> करते हैं
putStrLn ( वर्णन कर्लोक )
कर्लोक चलाएं
गो दिर -> करो
putStrLn ( " \ n आप चलने के लिए" ++ शो dir ++ "। \ n " )
रन ( वॉक कर्लोक दिर )
ConvertResult -> करते हैं
putStrLn ( evalAction ConvertResult )
putStrLn "बारी का अंत। \ n "
कर्लोक चलाएं

अंतिम भाग के टास्क नंबर 2 में, दो कॉल "(वर्णन कर्लोक)" से बचने के तरीके के बारे में सोचने का प्रस्ताव था। बेशक, हम एन निकायों के लिए गुरुत्वाकर्षण समस्या को हल नहीं करते हैं ताकि एक छोटे से फ़ंक्शन के उदाहरण का उपयोग करके संसाधनों के लिए लड़ सकें, लेकिन कई महत्वपूर्ण परिणाम इस महत्व का पालन करते हैं। यदि हमारे पास एक अनिवार्य भाषा है, तो हम परिणाम को एक चर के लिए आवंटित करेंगे। हास्केल में, डेटा अपरिवर्तनीय माना जाता है, इसलिए ऐसा कोई असाइनमेंट नहीं है। लेकिन ऐसे अन्य तंत्र हैं, जो जैसा कि यह बताते हैं, न केवल असाइनमेंट को सामान्य करता है, बल्कि अपरिवर्तित स्थिति को भी ध्यान में रखता है, दिलचस्प प्रभाव देता है। उदाहरण के लिए, निष्पादन का निर्धारणवाद। वास्तव में, यदि कुछ वैश्विक स्थिति फ़ंक्शन को प्रभावित नहीं करती है, और इसके अंदर डेटा स्पष्ट रूप से अपरिवर्तित है, तो इसका मतलब है कि यह समान मानों को समान तर्कों को वापस कर देगा। फ़ंक्शन को एक बार कॉल करके, हम इसके मापदंडों और परिणाम को याद कर सकते हैं, और अगर हमें इसे उसी मापदंडों के साथ दूसरी बार कॉल करने की आवश्यकता है, तो हम केवल पहले गणना किए गए परिणाम को वापस कर देते हैं, क्योंकि हम इसके बारे में सुनिश्चित हैं।

लेकिन चलो व्यापार के लिए नीचे उतरो। हमारी समस्या के कई समाधान हैं। पहले, आइए, उदाहरण के लिए, परिणाम को कुछ चर के साथ संबद्ध करने के लिए, उसी तरह जैसे हमने गेटलाइन और चर x से रेखा को जोड़ा है। यह एक असाइनमेंट के समान है, और यहां विचार सरल है: आप चर का उपयोग उतना ही कर सकते हैं जितना आपको जरूरत है। पहली कॉल से आपको लगभग निम्नलिखित कोड मिलते हैं:

दौड़ना curLoc = करना
locDescr <- वर्णन कर्लोक
putStrLn locDescr
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
... - शेष कोड

लेकिन यह कोड एक चाल है क्योंकि यह अब संकलन नहीं करता है।

* मुख्य: आर
[ २ का २ ] मुख्य संकलन ( H: \ Haskell \ QuestTutorial \ Quest \ QuestMain । Hs , व्याख्या )

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 58 : 17 :
वास्तविक प्रकार ' IO ( ) ' के साथ अपेक्षित प्रकार ' [a ]] का मिलान नहीं हो सका
' PutStrLn ' के कॉल के रिटर्न प्रकार में
' Do ' एक्सप्रेशन के एक स्टम्ट में : putStrLn locDescr
अभिव्यक्ति में:
...

विफल , लोड किए गए मॉड्यूल: प्रकार ।

"X <- getLine" और "locDescr <- descriptionLocation curLoc" में क्या अंतर है? यह एक ही बात लगती है: गेटलाइन फ़ंक्शन एक स्ट्रिंग देता है जो चर x के साथ जुड़ा हुआ है; और फ़ंक्शन (डिस्क्रैक्लोकेशन कर्लोक) एक स्ट्रिंग भी लौटाता है जो किसी अन्य लोकड्रेस चर पर बांधता है। लेकिन दुभाषिया कहता है कि कुछ प्रकार मेल नहीं खाते हैं। आइए स्थिति को देखें - और इसके लिए आपको यह समझने की आवश्यकता है कि रन फ़ंक्शन में वास्तव में क्या होता है।

आइए त्रुटिपूर्ण रेखाओं पर टिप्पणी करते हुए वापस काम करने वाले कोड पर जाएं।

दौड़ना curLoc = करना
- लोकड्रेस <- वर्णनलोकलोक
- putStrLn locDescr
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
... - शेष कोड

* प्रकार > : आर
[ २ का २ ] मुख्य संकलन ( H: \ Haskell \ QuestTutorial \ Quest \ QuestMain । Hs , व्याख्या )
ठीक है , मॉड्यूल लोड किए गए: मुख्य , प्रकार ।
* मुख्य या

हमने जानबूझकर रन फ़ंक्शन की परिभाषा नहीं लिखी है, ताकि इसके प्रकार की जटिलताओं में न जाएं। लेकिन उसके पास एक प्रकार है, और संकलक इसे स्वयं प्रदर्शित करता है। की जाँच करें:

* मुख्य: टी रन
रन :: स्थान -> IO ( )

और यहां एक आश्चर्य हमें इंतजार कर रहा है। यह स्पष्ट है कि स्थान एक एकल पैरामीटर का प्रकार है, और अजीब प्रकार IO () के लिए, वापसी मूल्य के प्रकार के अलावा कुछ भी नहीं बचा है। बहुत दिलचस्प! आखिर, हम कहीं भी किसी भी IO () का उपयोग नहीं कर रहे हैं, यह कहां से आया है? यदि आप हास्केल को उसके काले कामों और मनमानी के लिए दोषी ठहराते हैं, तो आप जल्दबाजी न करें: IO हम इसका बहुत उपयोग करते हैं। तथ्य यह है कि हास्केल के अनुसार, किसी भी इनपुट-आउटपुट (I / O) कार्रवाई एक संभावित त्रुटि और खराबी है, जिसे "साइड इफेक्ट्स" के रूप में भी जाना जाता है। इसलिए, इनपुट-आउटपुट फ़ंक्शंस (putStrLn, putStr, putChar, getLine, getChar, readFile, writeFile) खतरनाक हैं, वे एक ही तर्कों पर अलग-अलग परिणाम दे सकते हैं, और कुछ मामलों में वे एक त्रुटि भी फेंक सकते हैं। इसलिए, वे प्रकार IO के हैं, जो भाषा की राय में, हमें चिंतित होना चाहिए। इसके अतिरिक्त, अन्य सभी कार्य जिनके अंदर एक IO प्रकार है, गैर-नियतात्मक भी बन जाते हैं और उन्हें इसे अपनाना चाहिए। हमारे रन फ़ंक्शन ने असुरक्षित कार्यों को चुना, यही वजह है कि यह IO () प्रकार से संक्रमित हो गया। यह इस तरह से है, कि कार्यक्रम में प्रवेश बिंदु - मुख्य कार्य - इस भाग्य से बच नहीं गया, क्योंकि रन को इसमें कहा जाता है।

* मुख्य: टी मुख्य
मुख्य :: IO ( )

निष्पक्षता में, यह कहने योग्य है कि स्पष्टीकरण में यह धारणा बनाई गई है कि IO क्रियाओं के साथ कार्य गैर-नियतात्मक हैं। वास्तव में, यह पूरी तरह से सच नहीं है; और एक अर्थ में ऐसे कार्य निर्धारक और शुद्ध भी हो सकते हैं। यह सवाल, आम तौर पर बोल रहा है, हास्केल की पवित्रता के बारे में बहस में एक ठोकर है, और इसकी चर्चा इंटरनेट पर पाई जा सकती है।

उपरोक्त हमारी समस्या से कैसे संबंधित है? चलो गलत कोड पर फिर से देखें (संकलन के बिना), इसे असाइन करने के लिए, ऑर्डर के लिए, रन फ़ंक्शन की परिभाषा।

रन :: स्थान -> IO ( )
दौड़ना curLoc = करना
locDescr <- वर्णन कर्लोक
putStrLn locDescr
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
... - शेष कोड

कीवर्ड, जैसा कि हम जानते हैं, क्रियाओं को एक श्रृंखला में जोड़ता है, लेकिन कोई भी नहीं। do- संकेतन के लिए आवश्यक है कि श्रृंखला की सभी क्रियाएं एक ही प्रकार की हो। चूंकि हम I / O के साथ काम करते हैं, इसलिए फ़ंक्शन के प्रकार में IO होना चाहिए।

* मुख्य: टी putStrLn
putStrLn :: स्ट्रिंग -> IO ( )

* मुख्य: टी पुटस्ट्र
putStr :: स्ट्रिंग -> IO ( )

स्ट्रिंग के प्रकार के तर्क के अलावा, इन दो कार्यों में एक ही रिटर्न प्रकार है - IO ()। यहां खाली कोष्ठक इंगित करते हैं कि कुछ भी उपयोगी नहीं है। वास्तव में, यह हमारे लिए महत्वपूर्ण नहीं है कि पुटस्ट्रल क्या रिटर्न देता है, अगर केवल यह कंसोल में अपने तर्क को प्रिंट करेगा। इसके विपरीत, हम getLine फ़ंक्शन से कुछ "उपयोगी" की उम्मीद करते हैं, और यह अपने प्रकार से अपने तरीके से परिलक्षित होता है:

* मुख्य: टी getLine
getLine :: IO स्ट्रिंग

getLine उपयोगकर्ता से एक स्ट्रिंग प्राप्त करता है और इसे एक उपहार के रूप में, IO प्रकार में पैक करता है। और जो आप उपहार के साथ चाहते हैं वह करें। उदाहरण के लिए, हम इसे ConvertStringToAction फ़ंक्शन में पास करते हैं:

...
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
...

लेकिन ConvertStringToAction फ़ंक्शन का एक अलग प्रकार है! - आपका धन्यवाद और आप सही होंगे। वह इनपुट पर स्ट्रिंग का इंतजार कर रही है, आईओ स्ट्रिंग का नहीं! चाल क्या है? खैर, इन दो पंक्तियों में कहीं न कहीं उपहार सामने आता है, आईओ बॉक्स को फेंक दिया जाता है, और खाली लाइन पहले से ही चलती रहती है। और यह तीर द्वारा किया जाता है। यह दाईं ओर से पैक्ड परिणाम लेता है और इसे बाईं ओर एक चर में खोल देता है। इसीलिए, वैसे, इस ऑपरेशन को बाध्यकारी कहा जाता है, असाइनमेंट नहीं। और अगर आप इसके बारे में सोचते हैं, तो हमारी अभिव्यक्ति "locDescr <- descriptionLocation curLoc" गलत है, क्योंकि सही पक्ष पर कहीं भी कुछ भी पैक नहीं किया गया है - पढ़ें, परिणाम IO बॉक्स में नहीं डाला गया है।

* मुख्य: टी ( वर्णन घर )
( वर्णन घर ) :: स्ट्रिंग

खैर, यहाँ हम हैं ... हम इसे जितना संभव हो उतना सरल चाहते थे, लेकिन हमें कई पन्नों के रूप में किस तरह का परिणाम मिला। लेकिन मेरे पास आपके लिए अच्छी खबर है: एक समाधान है! हम खुद टाइप I में दाईं ओर क्या पैक करेंगे, और तीर को चोक कर दें। इसके लिए रिटर्न फंक्शन है। निम्नलिखित कोड इरादा के अनुसार काम करेगा:

रन :: स्थान -> IO ( )
दौड़ना curLoc = करना
locDescr <- वापसी ( वर्णन वर्णन कर्लोक )
putStrLn locDescr
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
छोड़ो -> putStrLn " तुमको देखा ..."
देखो -> करते हैं
putStrLn locDescr
कर्लोक चलाएं
... - शेष कोड

हां, वापसी फ़ंक्शन स्ट्रिंग को डू (IO) ब्लॉक प्रकार में पैक करेगा, और तीर इसे अनपैक कर देगा और इसे locDescr चर के साथ जोड़ देगा। और आपको अब कई बार स्थान विवरण की गणना करने की आवश्यकता नहीं है। तर्क, बेशक, असामान्य है, लेकिन आपको सहमत होना चाहिए: इसमें किसी प्रकार की आंतरिक सुंदरता है। यह एक पेय के लायक है!

IO के do- अंकन और प्रकार के और भी अधिक परिणाम और नुकसान होते हैं। यदि हम गहराई से खुदाई करते हैं, तो हम न केवल दुष्प्रभावों को दूर करने के लिए एक सार्वभौमिक तरीका देखेंगे, बल्कि कई अन्य गणनाएं भी कर सकते हैं जो कि IO क्रियाओं की तुलना में विभिन्न कानूनों के अनुसार संबंधित हो सकती हैं। तथाकथित मठों का उपयोग करके गणना करना, हम आश्चर्यजनक रूप से सरल और सुविधाजनक तर्क के साथ समाप्त होते हैं, और कोड संक्षिप्त, समझने योग्य और अभिव्यंजक बन जाता है। यह महत्वपूर्ण है कि ऐसा कोड सख्ती से गणितीय और बहुत सुविधाजनक है। यह विशिष्ट कार्यों जैसे पार्सिंग, डीएसएल, म्यूटेबल स्टेट्स और बहुत कुछ के लिए बहुत उपयुक्त है। शायद किसी दिन हम इस विषय पर लौटेंगे - लेकिन इससे पहले नहीं वास्तव में इसकी आवश्यकता होगी।

खैर, हमने समस्या को हल किया, जो अप्रत्याशित रूप से कैपेसिटिव निकला। तो हम क्यों तनाव और कुछ अन्य समाधान के साथ आना चाहिए? हां, सामान्य तौर पर, समान के लिए: हास्केल के बारे में कुछ और जानने के लिए।

हमारा अगला समाधान जहां निर्माण का उपयोग करेगा। यह एक विशेष निर्माण है जहां आप उन कार्यों का वर्णन कर सकते हैं जो केवल यहां और अभी उपलब्ध हैं - जैसे कुछ अन्य प्रोग्रामिंग भाषाओं में नेस्टेड फ़ंक्शन। जहां ब्लॉक के अंदर, पेरेंट फ़ंक्शन के वैरिएबल उपलब्ध हैं, और साधारण कार्यों पर लागू होने वाले सभी कानून लागू होते हैं। इसका मतलब है कि आप एक ही फ़ंक्शन के कई वेरिएंट बना सकते हैं, पैटर्न मिलान, सुरक्षा अभिव्यक्तियों का उपयोग कर सकते हैं, और यहां तक ​​कि नेस्टेड भी बना सकते हैं जहां-निर्माण।

जहां निर्माण को किसी विशेष स्पष्टीकरण की आवश्यकता नहीं है, बस उदाहरण देखें:

रन :: स्थान -> IO ( )
दौड़ना curLoc = करना
putStrLn locDescr
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
छोड़ो -> putStrLn " तुमको देखा ..."
देखो -> करते हैं
putStrLn locDescr
कर्लोक चलाएं
... - शेष कोड
जहाँ
locDescr = वर्णनL कर्लोक

हम जहां ब्लॉक के रूप में खंड से पहले एक ही इंडेंट बनाया। अनिवार्य रूप से, हमने इस ब्लॉक के लिए कहां परिभाषित किया है। ऐसा लग सकता है कि हम परिणाम को चर लोकडासक को सौंप रहे हैं, लेकिन ऐसा नहीं है। यहां कोई चर और असाइनमेंट नहीं हैं; locDescr एक फ़ंक्शन है जो किसी स्थान का विवरण देता है। हम इस फ़ंक्शन को मूल कोड से, और दो बार कहते हैं; हालाँकि, यह केवल एक बार गणना की जाती है। हस्केल संकलक पुन: उपयोग के लिए पिछले परिणाम रख सकते हैं। जब डेटा की आवश्यकता नहीं होती है, तो यह अंतर्निहित कचरा कलेक्टर द्वारा हटा दिया जाता है। अंतिम भाग से साइडबार को याद रखें, जहां फाइबोनैचि संख्याओं की गणना की जाती है। यदि शुरू से ही मूल्यों की गणना बहुत शुरुआत से की गई थी, तो कार्यक्रम कैसे काम करेगा?

अंत में, अंतिम समाधान - तथाकथित लेट-एक्सप्रेशंस - सबसे सरल और, शायद, यहां सबसे उपयुक्त है। और हालाँकि, लेट-एक्सप्रेशन बहुत ही समान हैं जहाँ, वे अभिव्यक्ति उपनामों को परिभाषित करते हैं, ऐसे नामों के साथ कार्य नहीं करते हैं। डू ब्लॉक के अंदर, इस तरह की अभिव्यक्ति दिखाई देती है:

रन :: स्थान -> IO ( )
दौड़ना curLoc = करना
आज्ञा देना locDescr = वर्णनL कर्लोक
putStrLn locDescr
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
छोड़ो -> putStrLn " तुमको देखा ..."
देखो -> करते हैं
putStrLn locDescr
कर्लोक चलाएं
... - शेष कोड

यदि आप डो ब्लॉक के बाहर एक लेट-एक्सप्रेशन का उपयोग करते हैं, उदाहरण के लिए, अन्य अभिव्यक्तियों के अंदर, तो रिकॉर्ड थोड़ा बदल जाएगा। कीवर्ड में जोड़ा गया है:

रन :: स्थान -> IO ( )
दौड़ना curLoc =
आज्ञा देना locDescr = descriptionLocation curLoc in
करना
putStrLn locDescr
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
छोड़ो -> putStrLn " तुमको देखा ..."
देखो -> करते हैं
putStrLn locDescr
कर्लोक चलाएं
... - शेष कोड

वास्तव में, आप लेट इन - के बीच किसी भी संख्या में ऐसे भावों को परिभाषित कर सकते हैं और आप देखेंगे कि वस्तुओं को जोड़ने की दिशा में यह कैसे किया जाता है। इस बीच, हम पिछले विकल्प को छोड़ देंगे, जहां लेट-एक्सप्रेशन डो-ब्लॉक के अंदर होता है।

लेट-एक्सप्रेशन न केवल अच्छे हैं क्योंकि वे छोटे लिखे गए हैं, बल्कि इसलिए भी कि उनका उपयोग कुछ विशेष मामलों में किया जा सकता है। इसलिए, उदाहरण के लिए, एक ही उद्देश्य के लिए सूची बोध में डाला जा सकता है: एक सीमित दायरे के साथ एक अभिव्यक्ति को परिभाषित करने के लिए। हालाँकि, जहाँ इसके नुकसान भी हैं, उनकी तुलना में: आप गार्ड भाव और पैटर्न मिलान का उपयोग नहीं कर सकते। बेशक, चूंकि हम छद्म शब्दों को परिभाषित कर रहे हैं, इसलिए उनके दायरे में उन्हें दोहराया नहीं जाना चाहिए।

आप पूछते हैं कि हम वस्तुओं को कब प्राप्त करते हैं? मैंने पहले ही स्विच कर लिया है। क्या आप अभी तक नहीं हैं, या क्या? फिर पकड़ लो। ऑब्जेक्ट के लिए ADT टाइप बनाएं, जैसे:

डेटा ऑब्जेक्ट = तालिका
| छाता
| दराज
| फ़ोन
| मेलबॉक्स
| Friend'sKey
व्युत्पन्न ( Eq , शो , पढ़ें )

स्थानों की छवि में, वस्तुओं के विवरण के साथ एक फ़ंक्शन जोड़ें:

descriptionObject :: ऑब्जेक्ट -> स्ट्रिंग
वर्णन करें छाता = "अच्छा लाल मैकेनिक छाता।"
वर्णन तालिका = "दराज के साथ अच्छी लकड़ी की मेज।"
descriptionObject Phone = "फ़ोन में आपके लिए कुछ ध्वनि संदेश हैं।"
descriptionObject MailBox = "मेलबॉक्स बंद हो गया है।"
descriptionObject obj = "" ++ शो obj के बारे में कुछ खास नहीं है

कोई चाल नहीं है, हम पहले से ही यह सब जानते हैं और हम सक्षम हैं। एक नया शुरू होता है जब हमें स्थानों के लिए वस्तुओं को परिभाषित करने की आवश्यकता होती है। हम निश्चित रूप से चाहेंगे कि सब कुछ तैयार था, टेक एंड ड्राप ने काम किया, एक इन्वेंट्री थी, कंपाउंड ऑब्जेक्ट थे ... लेकिन ऐसा नहीं होता है। अब हम उन स्थानों में वस्तुओं का एक मसौदा संस्करण बनाएंगे, जहां उन्हें न तो ले जाया जा सकता है और न ही फेंका जा सकता है, और इसके आधार पर हम अन्य, अधिक उन्नत और उपयुक्त तंत्रों के साथ आएंगे।

मान लीजिए, होम लोकेशन में, जहां खेल शुरू होता है, कई ऑब्जेक्ट हैं, और उनमें से एक टेबल, टेबल ड्रावर, एक टेलीफोन और एक छाता है। हम स्थान पर आधारित फ़ंक्शन सेट करते हैं, जो इस स्थान के लिए ऑब्जेक्ट की सूची लौटाएगा:

स्थान : स्थान :: स्थान -> [ वस्तु ]
स्थानविशेष होम = [ छाता , दराज , फोन , टेबल ]
locationObjects _ = [ ]

सामान्य तौर पर, सूचियां सरल दिखती हैं। वस्तुओं की एक सूची [वस्तु] का एक प्रकार है। होम लोकेशन के लिए, हम चार ऑब्जेक्ट्स की सूची लौटाते हैं। एक खाली सूची को खाली वर्ग कोष्ठक द्वारा इंगित किया जाता है, इसलिए जब तक कि अन्य सभी स्थान वस्तुओं के बिना न हों। यह आगे बढ़ने से पहले कोड का परीक्षण करने के लायक है।

* मुख्य : स्थानविशेष होम
[ छाता , दराज , Phome , टेबल ]

* मुख्य - स्थानओबजेक्ट्स गार्डन
[ ]

* मुख्य : वर्णन तालिका को हटाएं
"दराज के साथ अच्छी लकड़ी की मेज।"

चूंकि ऑब्जेक्ट प्रकार शो प्रकार वर्ग से विरासत में मिला है, इसलिए हम न केवल प्रकार के निर्माणकर्ताओं के लिए, बल्कि इस प्रकार की सूची के लिए भी शो फ़ंक्शन का उपयोग कर सकते हैं:

* मुख्य : छाता दिखाते हैं
«छाता»

* मुख्य शो [ छाता , टेबल ]
"[छाता, टेबल]"

* मुख्य : शो ( स्थानऑब्जेक्ट होम )
"[छाता, दराज, फोन, टेबल]"

* मुख्य : putStrLn ( शो ( स्थानऑब्जेक्ट होम ) )
[ छाता , दराज , फोन , टेबल ]

आक्षेप भी सत्य है। यदि सूची आइटम को रीड फंक्शन द्वारा पार्स किया जा सकता है, तो पूरी सूची को भी पार्स किया जा सकता है:

* मुख्य : "[टेबल, मेलबॉक्‍स]" :: [ वस्तु ] पढ़ें
[ टेबल , मेलबॉक्स ]

अब जब हम वाक्य रचना को समझ गए हैं, तो हम इसे बना देंगे ताकि वर्तमान स्थान के लिए न केवल इसका विवरण प्रदर्शित हो, बल्कि वहां मौजूद वस्तुओं की एक सूची भी छपे। लेट-एक्सप्रेशंस का उपयोग करते हैं:

दौड़ना curLoc = करना
आज्ञा देना locDescr = वर्णनL कर्लोक
आइए ऑब्जेक्ट्सस्क्रेस = " \ n यहां कुछ ऑब्जेक्ट्स हैं:" ++ शो ( लोकेशनऑब्जेक्ट कर्लोक )
आज्ञा देना fullDescr = locDescr ++ ObjectsDescr
putStrLn fullDescr
... - कोड के बाकी, देखो कार्रवाई को अद्यतन करने के लिए मत भूलना।

कार्यक्रम का आउटपुट अब इस तरह दिखता है:

* मुख्य - मुख्य
हास्केल पर क्वेस्ट साहसिक ।

घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।
यहाँ कुछ वस्तुएँ हैं: [ छाता , दराज , फोन , टेबल ]
कमांड दर्ज करें:

कोड में थोड़ा उपद्रव है। यहां तक ​​कि अगर स्थान में कोई ऑब्जेक्ट नहीं हैं, तो शिलालेख "यहां कुछ ऑब्जेक्ट हैं:" अभी भी हमारे लिए एक नजर होगी।

कमांड दर्ज करें: उत्तर जाओ

आप उत्तर की ओर चलना ।

उद्यान
आप बगीचे में हैं । .....
यहाँ कुछ वस्तुएँ हैं: [ ]
कमांड दर्ज करें:

वस्तुओं की एक खाली सूची के लिए इसे प्रदर्शित नहीं करने के लिए, हम वस्तुओं को अलग फ़ंक्शन में वर्णन करने के लिए सभी कोड डालते हैं, इसे enumerateObjects कहते हैं। इनपुट पर, यह एक सूची लेता है, और आउटपुट में यह सूचीबद्ध वस्तुओं के साथ एक स्ट्रिंग गुजरता है।

enumerateObjects :: [ वस्तु ] -> स्ट्रिंग
enumerateObjects [ ] = ""
enumerateObjects ऑब्जेक्ट्स = " \ n यहां कुछ ऑब्जेक्ट्स हैं:" ++ ऑब्जेक्ट्स दिखाते हैं

EnumerateObjects फ़ंक्शन का पहला संस्करण एक रिक्त स्ट्रिंग देता है - लेकिन केवल तब जब स्थानांतरित ऑब्जेक्ट्स की सूची रिक्त हो। यदि यह खाली नहीं है, तो पहला विकल्प खारिज कर दिया जाएगा, और दूसरा काम करेगा। रन फ़ंक्शन:

दौड़ना curLoc = करना
आज्ञा देना locDescr = वर्णनL कर्लोक
आज्ञा देना ऑब्जेक्ट्स = enumerateObjects ( स्थानऑब्जेक्ट्स curLoc )
आज्ञा देना fullDescr = locDescr ++ ObjectsDescr
putStrLn fullDescr
... - ...

या, यदि आप चाहें, तो आप do block से लेट एक्सप्रेशन निकाल सकते हैं:

दौड़ना curLoc =
चलो
locDescr = वर्णनL कर्लोक
ऑब्जेक्टड्रेसर = enumerateObjects ( स्थानऑब्जेक्ट कर्लॉक )
fullDescr = locDescr ++ ObjectsDescr
में करते हैं
putStrLn fullDescr
... - ...

इस सरल रीफैक्टरिंग के लिए धन्यवाद, अब हम रन को प्रभावित किए बिना enumerateObjects फ़ंक्शन को संशोधित कर सकते हैं। इसलिए हम चाहते थे, कहें कि केवल वस्तुओं को ही न रखें, बल्कि उनके विवरणों को भी प्रदर्शित करें, - इसलिए हम अपने चंचल कलमों के साथ हमारे enumerateObjects में चढ़ते हैं और वहां कुछ चतुरता को ठीक करते हैं। लेकिन किसी तरह बाद में। अब आइए जोड़ते हैं कस्टम एक्शन इनवेस्टिगेट। इस कमांड द्वारा, प्रोग्राम को ऑब्जेक्ट का विस्तृत विवरण देना चाहिए। यह स्पष्ट है कि उपयोगकर्ता को कुछ इस तरह दर्ज करना चाहिए:

कमांड दर्ज करें: छाता की जांच करें

लाइन "इन्वेस्टिगेट अम्ब्रेला" को पार्स करना होगा। परिचित, है ना? गो टीम के साथ हम पहले ही इससे गुजर चुके थे। यहाँ एक ही बात है: बस एक ऑब्जेक्ट पैरामीटर को इंवेस्टिगेट कंस्ट्रक्टर में डालें।

डेटा एक्शन =
...
| वस्तु की जांच करना
...

केवल थोड़ा रह गया - रन फ़ंक्शन को सही करने के लिए:

दौड़ना curLoc = करना
...
...
मामला ( ConvertStringToAction x ) का
जाँच करें obj -> करते हैं
putStrLn ( विवरण लिखें obj )
कर्लोक चलाएं
...

और वोइला! आपने एक अन्य उपयोगकर्ता कार्रवाई लागू की है! बधाई! आप यह जांच सकते हैं कि यदि आप "छाता की जांच करें" कमांड दर्ज करते हैं, तो प्रोग्राम स्ट्रिंग "अच्छा लाल यंत्र छाता" प्रदर्शित करेगा। मैं धोखा नहीं दे रहा हूं।

यह सिर्फ ... क्या आप जानते हैं कि हमारे साथ क्या बुरा है? यदि हम होम लोकेशन में हैं, तो "इनवेस्टिगेट मेलबॉक्स" कमांड डालें, हमें मेलबॉक्स का विवरण दिया जाएगा, जो यहाँ से दिखाई नहीं देता है! ठीक है, फिर हम एक अदृश्य फ़ंक्शन के साथ आएंगे, जो किसी ऑब्जेक्ट को देखने पर सही वापस आ जाएगा, और केवल इस मामले में हम ऑब्जेक्ट का विवरण जारी करेंगे। अदृश्य फ़ंक्शन के क्या तर्क हैं? हमें एक जांच की गई वस्तु, साथ ही सभी स्थान वस्तुओं की एक सूची की आवश्यकता है। कुछ इस तरह:

isV अदृश्य :: ऑब्जेक्ट -> [ ऑब्जेक्ट ] -> बूल

अब आपको किसी तरह यह पता लगाने की जरूरत है कि क्या इस सूची में कोई वस्तु है। हम सूची में सभी वस्तुओं की गणना के साथ "बेवकूफ" विकल्पों के साथ नहीं आएंगे, हालांकि यह बहुत संभव है, हम सिर्फ मानक एलएम फ़ंक्शन का उपयोग करते हैं। यह दो पैरामीटर लेता है: तत्व और सूची। यदि आइटम सूची में पाया जाता है, तो True लौटाता है। आपको क्या चाहिए!

isV अदृश्य :: ऑब्जेक्ट -> [ ऑब्जेक्ट ] -> बूल
isVouble obj वस्तुएँ = हाथी obj वस्तुएँ

हास्केल में संकेतन का एक विशेष रूप है जिसमें एक फ़ंक्शन को उसके तर्कों के बीच रखा जाता है - अर्थ की अधिक स्पष्टता और पारदर्शिता के लिए। ऐसा करने के लिए, आपको फ़ंक्शन को रिवर्स एपोस्ट्रोफ़्स में संलग्न करना होगा, जो कि। बटन पर हैं।

isVaware ' :: ऑब्जेक्ट -> [ ऑब्जेक्ट ] -> बूल
isVouble 'obj ऑब्जेक्ट्स = obj ` elem` ऑब्जेक्ट्स

लेकिन एक ही फ़ंक्शन के "गूंगा" संस्करण। उनमें, हम मैन्युअल रूप से सूची के अंदर की वस्तु की तलाश करते हैं।

isVaware '' :: ऑब्जेक्ट -> [ ऑब्जेक्ट ] -> बूल
isVanish '' obj [ ] = गलत
isVaware '' obj ( o: os ) = ( obj == o ) || ( अदृश्य '' obj ओएस )

isVaware '' ' :: ऑब्जेक्ट -> [ ऑब्जेक्ट ] -> बूल
isVanish '' 'obj [ ] = गलत
isVanish '' 'obj ऑब्जेक्ट्स = ( obj == हेड ऑब्जेक्ट्स ) || ( अदृश्य '' 'ओब्ज ( टेल ऑब्जेक्ट्स ) )

वे उसी तरह काम करते हैं, अंतर केवल उपयोग किए गए साधनों में होता है। वहाँ और वहाँ दोनों, सूची भागों में विभाजित है: प्रमुख तत्व और शेष तत्वों की पूंछ। पहले उदाहरण में, प्रविष्टि (ओ: ओएस) का उपयोग करके सूची को विभाजित किया गया है। यह स्पष्ट है कि चर "ओ" में सिर होता है, और चर "ओएस" में बाकी सब कुछ होता है। दूसरे उदाहरण में, हम वही करते हैं, केवल सिर और पूंछ सूची के ऊपर अंतर्निहित कार्यों के साथ। अगला, हम बस यह जांचते हैं कि क्या वस्तु प्रधान तत्व से मेल खाती है, और यदि नहीं, तो शेष तत्वों के लिए अदृश्य रूप से कॉल करें। पुनरावृत्ति को अनंत होने से रोकने के लिए, हमने फ़ंक्शन का एक प्रकार जोड़ा “अदृश्य ओब्ज [] = गलत” - यह काम करेगा अगर हम अचानक सूची से सभी तत्वों को काटते हैं और कुछ भी नहीं रहता है।

वैसे, इस सुविधा का उपयोग करना बाकी है। हमेशा की तरह, हम बदलेंगे, और कई बार वर्तमान स्थान की वस्तुओं का अनुरोध नहीं करने के लिए, हम उन्हें एक अभिव्यक्ति में डाल देंगे:

दौड़ना curLoc = करना
locObjects = locObjects कर्लोक दें
आज्ञा देना locDescr = वर्णनL कर्लोक
आज्ञा देना वस्तुएँ = enumerateObjects locObjects
आज्ञा देना fullDescr = locDescr ++ ObjectsDescr
putStrLn fullDescr
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
मामला ( ConvertStringToAction x ) का
जाँच करें obj -> करते हैं
यदि ( अदृश्य obj locObjects है )
उसके बाद putStrLn ( विवरण लिखें obj )
बाकी putStrLn ( "आप यहां कोई" ++ शो obj ++ " नहीं देखते हैं।" )
कर्लोक चलाएं
छोड़ो -> putStrLn " तुमको देखा ..."
... - बाकी कोड

वह सब है। हम इस प्रमुख नोट पर रोक देंगे - यह आराम करने का समय है, हमें पहले से ही ज्ञान की एक बड़ी गाड़ी मिल गई है।

फिक्सिंग के लिए असाइनमेंट।

1. ऑब्जेक्ट्स से संबंधित सभी फ़ंक्शन को ऑब्जेक्ट्स मॉड्यूल में ट्रांसफ़र करें, और स्थानों से संबंधित सभी फ़ंक्शंस को लोकेशन मॉड्यूल में स्थानांतरित करें।
2. निम्नलिखित रूप में स्थान वस्तुओं का एक प्रयोगात्मक निष्कर्ष बनाएं:

  घर
 आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं।
   यहाँ कुछ वस्तुएँ हैं:
      छाता: अच्छा लाल मैकेनिक छाता।
      तालिका: दराज के साथ अच्छी लकड़ी की मेज।
      फोन: फोन में आपके लिए कुछ आवाज संदेश हैं।
     Drawer: There is nothing special about Drawer. 

3. Investigate, . run :

...
Investigate obj -> do
putStrLn ( investigate obj locObjects )
कर्लोक चलाएं
...

इस भाग के लिए सूत्र ।

सामग्री की तालिका, संदर्भों की सूची और अतिरिक्त जानकारी ग्रीटिंग्स में मिल सकती है।