हास्केल क्वेस्ट ट्यूटोरियल - घाटी दृश्य

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

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

भाग ४
जिसमें हम रीफैक्टरिंग करेंगे, कुछ क्रियाओं को कार्यान्वित करेंगे, पैटर्न मिलान और पुनरावृत्ति के बारे में जानेंगे, और खोज से बाहर एक वास्तविक कार्यक्रम भी बना सकते हैं।


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

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

सब ठीक है। हम कोशिश करते हैं:

* मुख्य : घर चलाते हैं
घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।
कमांड दर्ज करें: देखो
क्रिया: देखो !
* मुख्य या

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

दौड़ना curLoc = करना
putStrLn ( वर्णन कर्लोक )
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
putStrLn ( evalAction ( ConvertStringToAction x ) )
putStrLn "बारी का अंत। \ n " - नई चाल - एक नई लाइन से।
कर्लोक चलाएं

- परीक्षण:

* मुख्य : घर चलाते हैं
घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।
कमांड दर्ज करें: देखो
क्रिया: देखो !
बारी का अंत ।

घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।
Enter कमांड: < Ctrl + C > बाधित ।

कार्यक्रम को आज्ञाकारी रूप से शुरू से बैरल अंग ने शुरू किया। हमारे पास अभी तक पर्याप्त ईवेंट हैंडलिंग नहीं है, इसलिए प्रोग्राम को बाधित करने का एकमात्र तरीका <Ctrl + C> है। और क्विट कमांड में उसकी प्रतिक्रिया करने के लिए, थोड़ी रिफैक्टिंग की जरूरत होती है। हम रन फ़ंक्शन को निम्नानुसार लिखते हैं:

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

हाँ, कुछ आइए यह चेहरा गड़बड़ है! ..। रन फ़ंक्शन की शुरुआत आपके लिए परिचित है। बहुत शुरुआत में कीवर्ड एक श्रृंखला में क्रियाओं को जोड़ता है। इस श्रृंखला में कौन से कार्य शामिल हैं? केवल चार: (स्थान का विवरण प्रिंट करें) - (लाइन दर्ज करें "कमांड दर्ज करें: () - (उपयोगकर्ता से एक स्ट्रिंग प्राप्त करें और इसे चर x के साथ संबद्ध करें) - (केस-निर्माण के अंदर अभिव्यक्ति को निष्पादित करें)। जब निष्पादन मामले में पहुंचता है, तो यह वांछित विकल्प पर कूद जाता है और पहले से ही जारी रहता है। मान लीजिए कि उपयोगकर्ता ने "छोड़ दिया" दर्ज किया है, और फिर फ़ंक्शन (ConvertStringToAction x) क्विट कंस्ट्रक्टर को लौटाता है, जिसका अर्थ है कि पहला विकल्प काम करना चाहिए। इस विकल्प में, केवल एक कार्रवाई - प्रिंट «आप में देखा जाना चाहिए ...» लाइन। कहीं भी कोई और कार्रवाई नहीं है - न तो क्विट विकल्प के अंदर, न ही केस-कंस्ट्रक्शन के बाद, इसलिए रन फ़ंक्शन के पास करने के लिए अधिक कुछ नहीं है, और यह समाप्त हो जाएगा। अब मान लीजिए कि उपयोगकर्ता "छोड़ो" नहीं है, लेकिन "देखो," तो क्या होता है? यह स्पष्ट है कि क्विट विकल्प काम नहीं करेगा, लेकिन अन्यथा यह हमेशा गार्ड पर रहता है - जहां निष्पादन जारी रहेगा। और क्या है? एक और कीवर्ड करते हैं! तो, क्रियाओं की एक नई श्रृंखला यहां शुरू हुई है, और इसे ठीक उसी तरह से किया जाता है, चरणों में। इस श्रृंखला में कौन से कार्य शामिल हैं? केवल तीन: (प्रोसेस्ड कमांड प्रिंट करें) - (लाइन को "एंड ऑफ टर्न। \ N" प्रिंट करें) - (रन फंक्शन को रन करें)।

पहली नज़र में, फ़ंक्शन समझ से बाहर है: ये सभी मामले, करते हैं, बाएं और दाएं तीर! लेकिन अगर आप सावधानीपूर्वक कार्यान्वयन की निगरानी करते हैं तो सब कुछ ठीक हो जाता है। हमें केवल यह जांचने की आवश्यकता है कि क्या कार्यक्रम वास्तव में वैसा ही काम करता है जैसा हम सोचते हैं।

* मुख्य : घर चलाते हैं
घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।
कमांड दर्ज करें: देखो
क्रिया: देखो !
बारी का अंत ।

घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।
कमांड दर्ज करें: छोड़ें
देखा आपने ...
* मुख्य या

हुर्रे! हम अच्छी तरह से कर रहे हैं! लेकिन हमारा रन फंक्शन अभी भी आदर्श से बहुत दूर है। कृपया ध्यान दें कि इसमें दो बार कॉल (ConvertStringToAction x) शामिल है, और यह खराब है। सौभाग्य से, फ़ंक्शन ConvertStringToAction सरल है, इसके लिए संसाधनों की आवश्यकता नहीं होती है, अन्यथा यह ओवररन होगा। हास्केल में, और किसी भी अन्य भाषा में, पुनरावृत्ति से बचा जाना चाहिए। चूंकि यह कॉल हमारे केस-कंस्ट्रक्शन में है, इसलिए इसके परिणाम को एक चर में रखा जा सकता है। रन फ़ंक्शन को थोड़ा बदलें:

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

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

खैर, यह बहुत मुश्किल था, इसलिए आज के लिए बस इतना ही।

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

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

प्रत्येक ब्लॉक का अपना इंडेंटेशन है, और आपको उन्हें मिश्रण करने की आवश्यकता नहीं है।

किसने कहा कि आप विचलन कर सकते हैं? हम जारी रखते हैं! बेशक, आप पहले से ही कार्यक्रम को बेहतर बनाने की योजना बना रहे हैं। और ठीक ही तो है! किसी दिन लुक कमांड के लिए वास्तविक (और काल्पनिक नहीं) प्रसंस्करण जोड़ें, लेकिन अब गो कमांड के बारे में सोचते हैं। इसे Zork में कैसे लागू किया जाता है?

क्लियरिंग
...

> पश्चिम जाओ
वन
...

यदि हम "गो वेस्ट" लिखते हैं, तो कमांड पार्सर दुखी हो जाएगा क्योंकि यह उसके लिए स्पष्ट नहीं है कि इस लाइन को कैसे पार्स किया जाए:

* मुख्य : घर चलाते हैं
घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।
एंटर कमांड: गो वेस्ट
*** अपवाद: प्रस्तावना । पढ़े : नहीं

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

* मुख्य: टाइप होम
घर :: स्थान

* मुख्य: प्रकार पश्चिम
पश्चिम :: दिशा

* मुख्य: टाइप गो
जाओ :: क्रिया

हम कार्यों के बारे में क्या जानते हैं? यह सही है। कि उनके पास तर्क हो सकते हैं। और हमें क्या सवाल पूछना चाहिए? यह सही है। "यदि निर्माता कार्य कर रहे हैं, तो क्या इसका मतलब है कि उनके पास भी तर्क हो सकते हैं?" जैसा कि आपने अनुमान लगाया होगा, हाँ! ADT प्रकार को परिभाषित करते समय, आप यह निर्दिष्ट कर सकते हैं कि किस प्रकार के तर्क इस या उस निर्माता को दिए गए हैं। गो कंस्ट्रक्टर को एक निर्देश तर्क जोड़ें।

डेटा एक्शन =
देखो
| दिशा जाओ
| इन्वेंटरी
| लेना
| ड्रॉप
| जांच
| छोड़ना
| सहेजें
| भार
| नई
व्युत्पन्न ( Eq , शो , पढ़ें )

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

* मुख्य शो ( गो वेस्ट )
पश्चिम जाओ

* मुख्य : "गो नॉर्थ" :: एक्शन पढ़ें
उत्तर जाओ

* मुख्य: टी गो
गो :: दिशा -> क्रिया

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

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

- जांचें:

* मुख्य : घर चलाते हैं
घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।
एंटर कमांड: गो वेस्ट
आप पश्चिम जा रहे हैं !

यदि पार्सर लाइन में "गो समथिंग" को पहचानता है, तो विकल्प "गो डिर" काम करेगा, और वही "समथिंग" डायर चर में गिर जाएगा। खैर, फिर हम डीर चर के साथ काम करते हैं। जादू!

हास्केल में बीजीय डेटा प्रकार बेहतर है। शायद आपने पहले ही पता लगा लिया है कि तर्कों के साथ निर्माणकर्ताओं का उपयोग करते हुए, तीसरे भाग से "डंब कैलकुलेटर" कार्य को कैसे फिर से लिखना है। आपको कुछ इस तरह मिल सकता है:

data IntegerArithmOperation =
प्लस इंटेगर इंटेगर
| माइनस पूर्णांक पूर्णांक
| प्रोड्यूसर इंटेगर इंटेगर
| नेगेट इंटेगर

evalOp :: IntegerArithmOperation -> पूर्णांक
evalOp op = case op का
प्लस x y -> x + y - "op" पैरामीटर बदले में प्रत्येक विकल्प के लिए मैप किया गया है।
माइनस x y -> x - y - कौन सा नमूना आया, ऐसा विकल्प चुना गया है।
उत्पादन x y -> x * y - x और y के बजाय, संख्या जो हमने कंस्ट्रक्टर के साथ पारित की है, प्रतिस्थापित की जाती है।
नेगेट x -> - x - गणना का परिणाम देता है। उदाहरण के लिए, 2 * 3 = 6।

* मुख्य : evalOp ( प्लस 2 3 ) - (प्लस 2 3) दो तर्कों के साथ एक निर्माता है।
5
* मुख्य : evalOp ( माइनस 2 3 )
- 1
* मुख्य : evalOp ( उत्पादन 2 3 )
6
* मुख्य : evalOp ( नेगेट 5 )
- 5

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

चलना :: स्थान -> दिशा -> स्थान
curLoc toDir = मामला curLoc चलना
घर -> मामला
उत्तर -> गार्डन
दक्षिण -> मित्र की वायर्ड
अन्यथा -> घर
बगीचा -> मामला
उत्तर -> मित्र की वायर्ड
दक्षिण -> घर
अन्यथा -> गार्डन
- ... शेष विकल्प यहां जोड़ें।

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

चलना :: स्थान -> दिशा -> स्थान

घर चलना = बाग
घर दक्षिण चलना = मित्र की वायर्ड
वॉक गार्डन नॉर्थ = फ्रेंड्स वायर्ड
वॉक गार्डन साउथ = होम
चलना दोस्त की उत्तर = घर
वॉक फ्रेंड्सयार्ड साउथ = गार्डन
वॉकल करलोक = = कर्लोक

वाह, कितने चलते हैं! और सभी समान हैं, पिछले उदाहरण की तुलना में कम लाइनें हैं, और अधिक कार्यक्षमता है। यह कैसे काम करता है? बहुत सरल है। जब हम तर्क के साथ टहलने के फोन उपयुक्त विकल्प चुनें। उदाहरण के लिए, "वॉक गार्डन साउथ" - और चौथा चुना जाएगा, जो घर वापस आ जाएगा।

* मुख्य : गार्डन साउथ की सैर करें
घर

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

......
चलना दोस्त की उत्तर = घर
वॉक फ्रेंड्सयार्ड साउथ = गार्डन
वॉकल कर्लोक = कर्लोक


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

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 50 : 1 :
'वॉक' के समीकरणों में विभिन्न तर्क होते हैं
H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 50 : 1 - 24
H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 56 : 1 - 22
विफल , मॉड्यूल लोड किया गया: कोई नहीं ।

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

शीर्षलेख :: स्ट्रिंग -> चार
शीर्षलेखक ( ch: chs ) = ch

tailLetters :: स्ट्रिंग -> स्ट्रिंग
tailLetters ( ch: chs ) = chs

* मुख्य " हेडलेटर " अपहरण "
'ए'
* मुख्य " टेललेटर्स " अपहरण "
«Bduction»

अंतिम चरण रन फ़ंक्शन को संशोधित करना है। सब कुछ तुच्छ है: हम गो dir के विकल्प में क्रियाओं की एक श्रृंखला जोड़ते हैं, "\ n You चलता है" ++ शो dir ++ "। \ N" पर लाइन प्रदर्शित करते हैं, और रन फ़ंक्शन को फिर से चलाते हैं, लेकिन इस बार हमें नया वर्तमान स्थान मिलता है। ।

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

- जाँच करें

* मुख्य : घर चलाते हैं
घर
आप खड़े हैं ...
कमांड दर्ज करें: उत्तर जाओ

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

उद्यान
आप बगीचे में हैं । ...

वह, वास्तव में, सब है। जाओ काम करता है।

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

आप एक साधारण कार्यक्रम संकलित कर सकते हैं और संसाधन उपयोग की गतिशीलता को देख सकते हैं। कार्यक्रम पुनरावृत्ति के प्रत्येक चरण में फाइबोनैचि संख्याओं की गणना करता है और उनमें से अंतिम प्रदर्शित करता है।

- test.hs:

मॉड्यूल मुख्य जहां

तंतुओं = 0 : 1 : zipWith ( + ) तंतुओं ( पूंछ तंतु )

cnt चलाना = करना
putStrLn ( " \ n टर्न काउंट:" ++ शो cnt )
putStrLn $ दिखाने $ पिछले $ cnt ले fibs
रन ( cnt + 1 )

मुख्य = करते हैं
1 चलाएं

अनुकूलन के साथ संकलन:

ghc - O परीक्षण । hs

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

H: \ Haskell \ QuestTutorial \ Quest > gh QuestMain । hs
[ १ का १ ] संकलन मेन ( क्वेस्टमेन । एचएस , क्वेस्टमेन.ओ )

क्वेस्टमाइन । hs: 1 : 1
फ़ंक्शन 'मुख्य' मॉड्यूल 'मेन' में परिभाषित नहीं है

GHC संकलक का कहना है कि मुख्य मॉड्यूल में मुख्य फ़ंक्शन नहीं मिला। यह कैसे हास्केल कार्यक्रम का प्रवेश बिंदु बनता है। अन्य भाषाओं में, जहां एक या किसी अन्य में एक मुख्य कार्य है करने के लिए इसी तरह की। इसे QuestMain.hs फ़ाइल के नीचे जोड़ें:

मुख्य = करते हैं
PutStrLn "हास्केल पर क्वेस्ट साहसिक। \ n "
घर चलाओ

और फ़ाइल की शुरुआत में हम मुख्य मॉड्यूल को परिभाषित करते हैं, जिसमें हमारे सभी कार्य झूठ होंगे:

मॉड्यूल मुख्य जहां

अब संकलक स्रोत को सुरक्षित रूप से खाता है, और आप निष्पादन योग्य फ़ाइल देखेंगे। मेरे पास यह QuestMain.exe है। अन्य बातों के अलावा, एक्सटेंशन .o और .hi वाली फाइलें दिखाई देंगी - ये अस्थायी फाइलें हैं (ऑब्जेक्ट और इंटरफेस वाली फाइल)। यदि वे आपको परेशान करते हैं, तो आप उन्हें हटा सकते हैं। जबकि परियोजना छोटी है, वे एक विशेष भूमिका नहीं निभाते हैं। फिर वे, अन्य भाषाओं की तरह, आंशिक संकलन के लिए उपयोग किया जा सकता है, जो खरोंच से संकलन की तुलना में काफी तेज है। उदाहरण के लिए, यदि एक मॉड्यूल को एक बार संकलित किया गया था और अब नहीं बदला गया है, जिस तरह के मॉड्यूल जिस पर यह निर्भर करता है वह नहीं बदला है, तो इसे पुन: संकलित करने की आवश्यकता नहीं है, बस पुरानी .o और .hi फ़ाइलों को लें। इसलिए, कोड को मॉड्यूल में अलग करना अच्छा अभ्यास है; इससे भी बेहतर - मॉड्यूल और फ़ोल्डरों द्वारा; और भी बेहतर - मॉड्यूल, फ़ोल्डर्स और पुस्तकालयों द्वारा।

आइए हमारी खोज को दो मॉड्यूल में विभाजित करें: प्रकार मॉड्यूल और मुख्य मॉड्यूल। ऐसा करने के लिए, टाइप करें। टाइप्स फ़ाइल, बहुत ऊपर इसे "मॉड्यूल प्रकार जहाँ" लाइन का उपयोग करके एक मॉड्यूल के रूप में परिभाषित करें और वहां क्वेस्टमैन्स फ़ाइल से सभी एडीटी प्रकारों को स्थानांतरित करें।

- Types.hs:

मॉड्यूल प्रकार कहाँ

डेटा स्थान =
घर
| ...
व्युत्पन्न ( Eq , शो , पढ़ें )

डेटा दिशा =
उत्तर
| ...
व्युत्पन्न ( Eq , शो , पढ़ें )

डेटा एक्शन =
देखो
| दिशा जाओ
| ...
व्युत्पन्न ( Eq , शो , पढ़ें )

यदि ghci अब कमांड निष्पादित करता है: r, दुभाषिया घबरा जाएगा: यह इन प्रकारों को नहीं जानता है!

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

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 4 : 21 :
स्कोप में नहीं: टाइप कंस्ट्रक्टर या क्लास 'लोकेशन'

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 7 : 13 :
दायरे में नहीं: डेटा कंस्ट्रक्टर 'होम'

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 8 : 13 :
दायरे में नहीं: डेटा कंस्ट्रक्टर 'फ्रेंड्स वायर्ड'

... और ऐसी बीस और लाइनें हैं ।

प्रस्तावना >

इससे कोई फर्क नहीं पड़ता! हम अपने मॉड्यूल प्रकार कनेक्ट करना होगा - और वे मुख्य में दिखाई जाएगी। "मॉड्यूल मेन कहाँ" के तहत मुख्य मॉड्यूल के शीर्ष पर कहीं, एक सरल रेखा जोड़ें:

- QuestMain.hs:
मॉड्यूल मुख्य जहां

आयात प्रकार
- ... बाकी कोड ...

अब संकलन सफल है। हमारे पास नोटिस करने का समय है: पहले से ही दो संकलित फाइलें हैं, जो तार्किक है।

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

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

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

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

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

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