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

वन
यह एक जंगल है, जिसमें सभी दिशाओं में पेड़ हैं। पूर्व की ओर, सूर्य का प्रकाश प्रतीत होता है।
आप दूरी में गीत पक्षी की चहकती सुनाई देती हैं।

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

भाग २
जिसमें हम डिस्क्रिमिनेशन फ़ंक्शन को यातना देंगे, और यह भी पता लगा लेंगे कि एडीटी क्या है।

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

QuestMain.hs फ़ाइल में आपके द्वारा लिखी गई सभी चीज़ों को मिटा दें। अगर यह धोने के लिए एक दया है, तो इसे छोड़ दें या संस्करण नियंत्रण प्रणाली (git, svn) का उपयोग करें: मैं आपको विश्वास दिलाता हूं, कि आप गलती से कोड को तोड़ने के लिए हमेशा के लिए गायब हो जाएंगे! जब चाहें कोड का कोई भी संस्करण देखा और पुनर्स्थापित किया जा सकता है। हास्केल कार्यक्रमों को फिर से भरना अपने आप में एक खुशी है, और एक संस्करण नियंत्रण प्रणाली के साथ यह सभी बोझ पर नहीं है। हां, रिफैक्टिंग भी आनंददायक हो सकती है! आप संपादित करें, हास्केल कोड को संपादित करें ताकि यह अंत में संकलित हो, और जब यह संकलित होता है, तो यह काम करना शुरू कर देता है! गलतियों का वह हिस्सा जो आपने अनिवार्य भाषा में किया होगा, बस यहाँ असंभव है। तर्क त्रुटियां अभी भी बनी हुई हैं, लेकिन खोजना और ठीक करना मुश्किल नहीं है, और एक संस्करण नियंत्रण प्रणाली के साथ यह और भी आसान है। इसके अलावा, सौ या दो संपादन वाले लॉग इस बात का एक अच्छा उदाहरण हैं कि आपने कैसे अच्छा काम किया है, और रास्ते से दिखाई देने वाले परिणाम आपको काम जारी रखने के लिए प्रेरित करते हैं।

पिछली बार, हम एक ऐसे समारोह के साथ आए थे जो अपनी संख्या के अनुसार किसी स्थान का विवरण देता है:

वर्णनस्थान locNumber = केस locNumber of
1 -> "आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"
2 -> "आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
अन्यथा -> "अज्ञात स्थान।"

यह किस प्रकार का कार्य हो सकता है? आइए अटकलें लगाते हैं। यह पूर्णांक (पूर्णांक) लेता है और एक स्ट्रिंग (स्ट्रिंग) लौटाता है, इसलिए प्रकार इस प्रकार होना चाहिए:

वर्णन वर्णन :: पूर्णांक -> स्ट्रिंग

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

* मुख्य : वर्णन 2.0
"आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
* मुख्य : वर्णन २.६
"अज्ञात स्थान।"

जब तक हम स्पष्ट रूप से प्रकार निर्दिष्ट नहीं करते, तब तक देखते हैं कि संकलक इसके बारे में क्या सोचते हैं:

* मुख्य: टाइप वर्णन
वर्णनस्थान : :: a => a -> [ चार ]

हम्म, प्रविष्टि "संख्या ए => ए -> [चार]" रहस्यमय और भयावह है। उसे जाने दो! हमें अभी तक इन कठिनाइयों की आवश्यकता नहीं है। फ़ंक्शन के सामने फ़ंक्शन परिभाषा जोड़ें और स्पष्ट रूप से सेट करें पूर्णांक, स्ट्रिंग:

वर्णन वर्णन :: पूर्णांक -> स्ट्रिंग
वर्णनस्थान locNumber = केस locNumber of
1 -> "आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"
2 -> "आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
अन्यथा -> "अज्ञात स्थान।"

की जाँच करें:

* मुख्य: टी विवरण
वर्णन वर्णन :: पूर्णांक -> स्ट्रिंग

ओह! यही बेहतर है। लेकिन, दुर्भाग्य से, हम एक अस्थायी-बिंदु संख्या को एक तर्क के रूप में पारित नहीं कर सकते हैं:

* मुख्य : वर्णन २
"आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
* मुख्य : वर्णन 2.0

< इंटरैक्टिव > : 1 : 18 :
( भग्न पूर्णांक ) के लिए कोई उदाहरण नहीं
शाब्दिक ' 2.0 ' से उत्पन्न
संभावित सुधार: ( भग्न पूर्णांक ) के लिए एक उदाहरण घोषणा जोड़ें
...

हमने पहले पैरामीटर के प्रकार को अधिक सामान्य (Num) से अधिक निजी (Integer) तक सीमित कर दिया, और इसे स्पष्ट कर दिया। फ़ंक्शन परिभाषाएँ वैकल्पिक हैं, लेकिन कोड उनके साथ स्पष्ट है। हास्केल में, प्रत्येक फ़ंक्शन को परिभाषित करने के लिए अच्छे रूप के नियमों में से एक है; कभी-कभी यह समझने के लिए पर्याप्त है कि एक फ़ंक्शन कैसे काम करना चाहिए।

क्या होता है: हम पहला तर्क (लोकेनम्बर) लेते हैं और इसे पहली स्थिति (पूर्णांक) में टाइप करते हैं। हमारे पास दूसरा पैरामीटर नहीं है, इसलिए दूसरी स्थिति का प्रकार रिटर्न मान (स्ट्रिंग) का प्रकार है। ठेस xy फ़ंक्शन याद रखें? वह किस प्रकार की होगी? यह इस प्रकार हो सकता है:

ठेस :: फ्लोट -> फ्लोट -> फ्लोट
ठेस x y = x * y

समझे? .. पहला फ्लोट x के लिए प्रकार है, दूसरा फ्लोट y के लिए प्रकार है, और अंतिम फ्लोट परिणाम का प्रकार है। वास्तव में, यह सब शर्मिंदगी है।

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

यहां हमें सोचना चाहिए कि हम स्थानों के बीच अंतर कैसे करेंगे। संख्या एक बहुत स्पष्ट पदनाम नहीं है, यह बेहतर होगा यदि यह कुछ महामारी है। शायद एक नाम के रूप में एक स्ट्रिंग? आइए कोशिश करते हैं:

वर्णनकरण :: स्ट्रिंग -> स्ट्रिंग
वर्णनस्थान locName = case locName of
"घर" -> "आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"
"फ्रेंड्स यार्ड" -> "आप छोटे लकड़ी के बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
अन्यथा -> "अज्ञात स्थान।"

* मुख्य : वर्णन "होम"
"आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"

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

* मुख्य : वर्णन "hOmE"
"अज्ञात स्थान।"

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

अपरकेसस्ट्रीमिंग :: स्ट्रिंग -> स्ट्रिंग
UpperCaseString str = ............ - किसी तरह हम सभी अक्षरों को बड़ा करते हैं।
वर्णनकरण :: स्ट्रिंग -> स्ट्रिंग
वर्णनस्थान locName = case ( UpperCaseString locName )
"गृह" -> "आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"
फ्राइड यार्ड -> "आप छोटे लकड़ी के बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
अन्यथा -> "अज्ञात स्थान।"

अब हिस्टेरिकल कैप्स लॉक डरावना नहीं है:

* मुख्य : वर्णन "फ्रिडन यार्ड"
"आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
* मुख्य : वर्णन "होमी"
"आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"

हाँ, मैं तुम्हारी उत्सुक आँखें देख रहा हूँ। UpperCaseString फ़ंक्शन चाहते हैं? क्या यह बहुत जल्दी नहीं है? ओह ठीक है। मेरे पास छिपाने के लिए कुछ नहीं है। हमें कुछ फ़ंक्शन, "टॉपर" की आवश्यकता होगी, यह मानक प्रस्तावना मॉड्यूल में नहीं है। वह "चार" मॉड्यूल से है, इसलिए आपको इसे कनेक्ट करने की आवश्यकता है:

आयात चार - QuestMain.hs की शुरुआत में हम चार मॉड्यूल कनेक्ट करते हैं

अपरकेसस्ट्रीमिंग :: स्ट्रिंग -> स्ट्रिंग
अपरकेस स्ट्रिंग = मैप टूपर स्ट्रैप

मैं यहाँ कुछ भी नहीं समझाता हूँ! खुद आगे बढ़ना चाहते थे - और समझे!

... अच्छा, ठीक है, राजी हो गया। सामान्य शब्दों में। नक्शा फ़ंक्शन दो तर्क लेता है: टॉपर फ़ंक्शन और हमारा स्ट्रिंग स्ट्रिंग। मानचित्र में एक सरल कार्य है: स्ट्रिंग स्ट्रिंग के प्रत्येक तत्व के लिए टॉपर फ़ंक्शन लागू करें। और किन तत्वों में तार होता है? सही, वर्णों से बाहर। इन सभी पात्रों के लिए टॉपर फ़ंक्शन लागू किया जाता है, जो उन्हें ऊपरी मामले में डालता है (ठीक है, अगर ये अक्षर हैं, तो निश्चित रूप से)।

एक और उपाय निरंतर कार्यों को जोड़ना है। आप उन्हें गलत नहीं लिख सकते, क्योंकि कार्यक्रम बस संकलन नहीं करता है!

घर :: स्ट्रिंग
घर = "गृह"

दोस्त का वायर्ड :: स्ट्रिंग - एपोस्ट्रोफ संकेत (') का उपयोग एक पत्र के रूप में अंदर और अंत में किया जा सकता है।
मित्र का वायर्ड = "मित्र का वचन "

बगीचा :: स्ट्रिंग
उद्यान = "गर्डन"

* मुख्य : वर्णन घर
"आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"
* मुख्य : वर्णन दोस्त का दोस्त
"आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
* मुख्य : वर्णन उद्यान
"अज्ञात स्थान।"

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

निष्पक्षता में, मुझे कहना होगा कि जब हम स्थानों को तार कहते हैं, तो हम कुछ डायनामिक्स को स्थिर कोड में पेश करते हैं। विकास के बाद के चरणों में, यह अचानक पता चल सकता है कि सामान्य तौर पर, यह एक अच्छा विचार था, क्योंकि स्थानों को जोड़ा और जोड़ा जा सकता है, लगभग कोड को बदले बिना। लेकिन तब डिस्क्रिमिनेशन फ़ंक्शन का एक अलग रूप होगा, और सामान्य तौर पर स्थानों के साथ काम करने का एक अलग दर्शन होगा। विवरण वर्णन के संपादन के बिना एक नया स्थान जोड़ने के लिए यह कैसे करें:

घर :: स्ट्रिंग
घर = "आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"

दोस्त का वायर्ड :: स्ट्रिंग
दोस्त का दिल = "आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"

बगीचा :: स्ट्रिंग
उद्यान = "आप बगीचे में हैं। गार्डन बहुत अच्छी तरह से दिखता है: साफ, पतला, ठंडा और गीला। "

वर्णनकरण :: स्ट्रिंग -> स्ट्रिंग
वर्णन स्थान = स्थान

* मुख्य : वर्णन उद्यान
“आप बगीचे में हैं। गार्डन बहुत अच्छी तरह से दिखता है: साफ, पतला, ठंडा और गीला। "

यही है, हम स्थान के विवरण के साथ एक स्थिर फ़ंक्शन का वर्णन करने के लिए पास करते हैं। वर्णन वर्णन फ़ंक्शन इसे लौटाता है। इस मामले में, केस-कंस्ट्रक्शन की आवश्यकता नहीं है, और हम कम से कम एक हज़ार फ़ंक्शंस-कॉन्स्टेंट का उत्पादन कर सकते हैं। वैसे, ध्यान दें कि हमारे निरंतर कार्य केवल तार से अलग नहीं हैं। चूंकि हास्केल में प्रत्येक अभिव्यक्ति एक फ़ंक्शन है, और एक स्ट्रिंग एक अभिव्यक्ति है, एक स्ट्रिंग एक फ़ंक्शन भी है। हमने केवल स्ट्रिंग का नाम दिया और एक स्थिर फ़ंक्शन मिला। (हम मान सकते हैं कि "pi" फ़ंक्शन भी एक स्थिर फ़ंक्शन है, कुछ इस तरह से है: pi = 3.1415 ....)

* मुख्य: दोस्त की ओर == "आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
यह सच है
* मुख्य: टी दोस्तयार्ड
दोस्त का नाम :: [ चार ]
* मुख्य: t "आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
"आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।" :: [ चार ]

यहाँ [चार] स्ट्रिंग के समान है। वस्तुतः, [चार] पात्रों की एक सूची है, स्ट्रिंग का एक पर्याय। हम स्ट्रिंग को [चार] से बदल सकते हैं या यहां तक ​​कि दोनों प्रकारों को एक कार्यक्रम में मिला सकते हैं, कोई त्रुटि नहीं होगी। लेकिन "वर्णों की सूची" की तुलना में "स्ट्रिंग" लिखना अधिक सुविधाजनक है। हम स्वयं अपने कई प्रकारों के लिए पर्यायवाची शब्द निर्धारित करेंगे। तो, मैंने adv2game में ObjectName को परिभाषित किया है, एक स्ट्रिंग (वर्णों की एक सूची) भी। ObjectName को देखते हुए, मैं समझता हूं कि यह सिर्फ एक स्ट्रिंग नहीं है, बल्कि, सिद्धांत रूप में, ऑब्जेक्ट का नाम होना चाहिए। समानार्थक शब्द टाइप कीवर्ड द्वारा निर्दिष्ट किए जाते हैं, जो C ++ में टाइपडिफ के समान काम करता है:

प्रकार ऑब्जेक्ट नाम = स्ट्रिंग

और इसलिए स्ट्रिंग प्रकार प्रस्तावना मॉड्यूल में सेट किया गया है:

टाइप स्ट्रिंग = [ चार ]

वर्ग कोष्ठक कहते हैं कि यह चार से एक सूची है। मान लें कि "STRING" वर्णों की सूची के समान है: ['S', 'T', 'R', 'I', 'N', 'G']। यह सिर्फ इतना है कि उनके दाहिने दिमाग में कोई भी इस रूप में एक स्ट्रिंग नहीं लिखेगा, क्योंकि हास्केल में पात्रों की सूची के लिए एक सरलीकरण है - "उद्धृत स्ट्रिंग्स"।

* मुख्य : [ 'S' , 'T' , 'R' , 'I' , 'N' , 'G' ]
«STRING»
* मुख्य : "मैं एक" ++ [ 'S' , 'T' , 'R' , 'I' , 'N' , 'G' ] ++ " हूं ।"
"मैं एक STRING हूं।"
* मुख्य : putStrLn [ 'S' , 'T' , 'R' , '\ n' , 'I' , 'N' , 'G' ]
एसटीआर
आईएनजी
* मुख्य - [ 'एस' , 'टी' , 'आर' , 'आई' , 'एन' , 'जी' ] == "STRING"
यह सच है

आप कुछ भी सूचियों को निर्दिष्ट कर सकते हैं: पूर्णांक की सूची [पूर्णांक], तार की एक सूची [स्ट्रिंग] (जो कि चार सूचियों की सूची में विस्तारित है), और इसी तरह। एफजे में सूची मुख्य संरचना है, और हम अभी भी उनके बारे में बहुत कुछ सीखते हैं।

क्या हम किसी तरह स्थानों के बीच अंतर करना चाहते हैं या नहीं? स्ट्रिंग नाम से नहीं, गलती करना इतना आसान है। काश एक तार के बजाय कुछ स्थायी होता। यहां:

वर्णन वर्णन :: ????? -> स्ट्रिंग
वर्णन स्थान = केस का स्थान
घर -> "आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"
मित्र का वायर्ड -> "आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
गार्डन -> "आप बगीचे में हैं। गार्डन बहुत अच्छी तरह से दिखता है: साफ, पतला, ठंडा और गीला। "
अन्यथा -> "अज्ञात स्थान।"

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

QuestMain.hs फ़ाइल की शुरुआत में, स्थानों के लिए प्रकार सेट करें:

डेटा स्थान = होम | दोस्त का यार | उद्यान

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

डेटा स्थान =
घर
| Friend'sYard
| उद्यान

साइन "|" "या" के रूप में पढ़ा जा सकता है। यही है, प्रकार के स्थान के चर एक मान ले सकते हैं: या तो होम, या मित्र का वायर्ड, या गार्डन। टाइप लोकेशन के कंस्ट्रक्टर्स को कॉल करके, हम इस प्रकार का एक वैरिएबल बनाते हैं। यह समझना महत्वपूर्ण है कि किसी भी निर्माणकर्ता को कॉल करते समय, हम अभी भी स्थान प्रकार के साथ काम कर रहे हैं, और "होम" या "गार्डन" जैसे प्रकार मौजूद नहीं हैं।

हम प्रश्नवाचक चिन्ह के बजाय एक नए प्रकार का विकल्प देते हैं:

वर्णन वर्णन :: स्थान -> स्ट्रिंग
वर्णन स्थान = केस का स्थान
घर -> "आप लकड़ी की मेज पर बीच के कमरे में खड़े हैं।"
मित्र का वायर्ड -> "आप लकड़ी के छोटे बाड़ के पीछे रात के बगीचे के सामने खड़े हैं।"
गार्डन -> "आप बगीचे में हैं। गार्डन बहुत अच्छी तरह से दिखता है: साफ, पतला, ठंडा और गीला। "
अन्यथा -> "अज्ञात स्थान।"

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

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

वर्णनहोमलोकेशन = वर्णनस्थान गृह
वर्णनगार्डलोकेशन = वर्णनलेक्शन गारडेन
वर्णनगार्डलोकेशन ' = वर्णनलोकेशन गारडेन

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

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 15 : 43 :
दायरे में नहीं: 'garDEN'

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 16 : 44 :
दायरे में नहीं: डेटा कंस्ट्रक्टर 'गारडेन'
विफल , मॉड्यूल लोड किया गया: कोई नहीं ।

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

डेटा स्थान =
स्थान - यह सही है, हालांकि यह स्पष्ट नहीं है कि क्यों।
| घर
| Friend'sYard
| उद्यान

कोई त्रुटि नहीं होगी, क्योंकि स्मार्ट हास्केल कंपाइलर जानता है कि किस स्थान को एक प्रकार के रूप में और कहां एक निर्माता के रूप में समझने की आवश्यकता है। और ये जगहें एक दूसरे को नहीं काटतीं। ("प्रकार और उनके निर्माता विभिन्न नामस्थानों में स्थित हैं।")

आइए भविष्य के लिए कल्पना करें कि हमारे पास अन्य प्रकार क्या होंगे।

- कमांड वॉक या गो पर कहां जाएं।
डेटा दिशा = उत्तर | दक्षिण | पश्चिम | पूर्व

- खिलाड़ी कार्रवाई।
डेटा एक्शन = देखो | जाओ | इन्वेंटरी | ले लो | गिरा | जांच करना | छोड़ो | बचाओ | लोड | नई

हम इन प्रकारों के साथ क्या कर सकते हैं? खैर, अभी तक इतना नहीं। हम एक ही प्रकार के कंस्ट्रक्टर्स की तुलना भी नहीं कर सकते हैं:

* मुख्य - उत्तर == उत्तर

< इंटरैक्टिव > : 1 : 7 :
( Eq दिशा ) के लिए कोई उदाहरण नहीं
' == ' के उपयोग से उत्पन्न
संभावित फिक्स: ( Eq दिशा ) के लिए एक उदाहरण घोषणा जोड़ें
अभिव्यक्ति में: उत्तर == उत्तर
'इट' के लिए एक समीकरण में: यह = उत्तर == उत्तर

दुभाषिया शिकायत करता है कि हमने कहीं भी नहीं लिखा है कि दिशा के प्रकार के निर्माणकर्ताओं की तुलना कैसे करें। जैसे, क्या आप ऑपरेशन "==" चाहते हैं? फिर अपने प्रकार को तुलना प्रकारों के परिवार में जोड़ें!

विशेष रूप से, वह आपको Eq प्रकार वर्ग में दिशा प्रकार जोड़ने के लिए कहता है। Eq एक प्रकार का वर्ग है जिसके लिए संचालन "==" और "/ =" परिभाषित किया गया है।

अब भूल जाओ कि इस साइडबार में क्या लिखा है। टाइप क्लास के बारे में बात करना हमारे लिए बहुत जल्दी है।

हमारे निर्माणकर्ताओं को तुलनीय बनाने के कई तरीके हैं। सबसे सरल एक प्रकार के जादू शब्दों की एक जोड़ी को जोड़ना है परिभाषा:

डेटा दिशा =
उत्तर
| दक्षिण
| पश्चिम
| पूर्व
व्युत्पन्न ( इक ) - बाएं किनारे से एक इंडेंट होना चाहिए।

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

* मुख्य - उत्तर == उत्तर
यह सच है
* मुख्य : उत्तर / = उत्तर
झूठा
* मुख्य = उत्तर == दक्षिण
झूठा

यह अच्छा है! अब हमारे पास "बराबर" और "बराबर नहीं" संकेत हैं। हमारे अन्य प्रकारों के साथ भी ऐसा ही करें - एक्शन और डायरेक्शन। काम में आ जाओ!

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

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

वाक फ़ंक्शन के साथ आओ - स्थानों के बीच यात्रा फ़ंक्शन। यह दो पैरामीटर लेता है: वर्तमान स्थान (स्थान) और दिशा (दिशा), और इस दिशा में स्थित एक नया स्थान देता है। प्रत्येक स्थान के लिए मार्ग योजना इस प्रकार है:

होम:
उत्तर - गार्डन
दक्षिण - मित्र की वायर्ड
पूर्व - घर
पश्चिम - घर

गार्डन:
उत्तर - मित्र की वायर्ड
दक्षिण - घर
पूर्व - बगीचा
पश्चिम - उद्यान

Friend'sYard:
उत्तर - घर
दक्षिण - बगीचा
पूर्व - मित्र का वायर्ड
पश्चिम - मित्र की वायर्ड

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

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