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

क्लियरिंग
आप एक अच्छी तरह से चिह्नित वन पथ में एक छोटे से समाशोधन में हैं जो पूर्व और पश्चिम तक फैला हुआ है।

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

भाग ३
जिसमें हम ADT के साथ जादू सीखेंगे और शो और रीड मैजिक कन्वर्टर्स के बारे में जानेंगे।

पिछले भाग में, हमने डिस्क्लेमर के लिए विभिन्न विकल्पों का आविष्कार किया, और अंत में हमने तीन बीजीय प्रकार बनाए - स्थान, दिशा, कार्य। मैंने एटीडी के जादू और अद्भुत विशेषताओं का उल्लेख किया, लेकिन कहा कि हम बाद में उन पर विचार करेंगे। हमें बस Eq प्रकार वर्ग से विरासत में मिला है, जिसमें "==" और "/ =" ऑपरेशन शामिल हैं, और अब ...

क्या आप चमत्कार चाहते हैं? खैर ... चलिए फिर से लोकेशन टाइप करते हैं:

डेटा स्थान =
घर
| Friend'sYard
| उद्यान
| OtherRoom - एक नया कंस्ट्रक्टर जोड़ा गया।
व्युत्पन्न ( इक )

* मुख्य - घर / = दोस्त की शादी
यह सच है
* मुख्य : घर == अन्यरुम
झूठा

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

* मुख्य: घर दिखाओ

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

यह काम नहीं किया ... हम पहले ही दूसरे भाग के अंत में एक समान त्रुटि का सामना कर चुके हैं। वहां हमने दो कंस्ट्रक्टरों की तुलना करने की कोशिश की, लेकिन इसका कुछ भी पता नहीं चला, क्योंकि घिसी को पता नहीं था कि उनकी तुलना कैसे की जाती है। हमने स्थान प्रकार के अंत में व्युत्पन्न (Eq) वर्तनी को जोड़कर समस्या को हल किया और हमें "फ़ैक्टरी" तुलनात्मक फ़ंक्शन "==" मिला। क्या हम शो फंक्शन पाने के लिए ऐसा कुछ कर सकते हैं? हम कर सकते हैं! यह शो प्रकार वर्ग को विरासत में देने के लिए पर्याप्त है:

डेटा स्थान =
घर
| Friend'sYard
| उद्यान
| OtherRoom
व्युत्पन्न ( Eq , दिखाएँ )

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

* मुख्य : घर दिखाओ
«होम»
* मुख्य : "वर्तमान स्थान का नाम:" ++ शो होम ++ "।"
"वर्तमान स्थान का नाम: होम।"
* मुख्य : फ्रेंड्स वायर्ड दिखाओ
«Friend'sYard»

इसका उपयोग कैसे किया जा सकता है? ओह, कई अलग-अलग तरीकों से। चलिए अब डिस्क्रिमिनेशन फ़ंक्शन को बेहतर बनाते हैं। हम अंतिम विकल्प को फिर से लिखते हैं (" अन्यथा "):

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

और अब, ghci की मदद का सहारा लिए बिना, मुझे बताओ: क्या होगा यदि आप "डिस्ट्रोकेशन अन्यरूम" कहते हैं? ट्रैक करें जहां OtherRoom कंस्ट्रक्टर मिलता है, केस कैसे काम करता है, विकल्पों में से किसको चुना जाता है, और यह विकल्प किस प्रकार का स्ट्रिंग लौटाएगा। हो गया क्या? खुद की जाँच करें:

* मुख्य : वर्णन अन्य
"अन्य नाम के साथ स्थान के लिए कोई विवरण उपलब्ध नहीं है।"

दुर्भाग्य से, मैं तुम्हारे लिए नहीं है; लेकिन अगर आपने सही अनुमान लगाया है, तो आप खुद पर गर्व कर सकते हैं। आपने केवल शो प्रकार वर्ग से शो फ़ंक्शन लिया और कंस्ट्रक्टर को स्ट्रिंग में बदल दिया। क्या यह सुंदर है? मेरी राय में, हाँ। उदाहरण के लिए, C ++ में, यह आसान है कि किसी एन्यूमरेशन के एक तत्व को स्ट्रिंग में बदलना आसान हो ...

शो फ़ंक्शन बहुत उपयोगी है। एक्शन और डायरेक्शन टाइप इनहेरिट शो क्लास से । मैं वादा करता हूँ कि आप हारेंगे नहीं!

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

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

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

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

बेशक, यह काम करेगा। यदि आप विवरणों को गलत करना चाहते हैं, तो कृपया। मुझे ऐसा महसूस नहीं हो रहा है। विकल्प संख्या दो:

वर्णन स्थान = केस का स्थान
होम -> शो लोक ++ " \ n " ++ "आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं।"
मित्र का वायर्ड -> शो लोक ++ " \ n " ++ "आप लकड़ी के छोटे बाड़ के पीछे नाइट गार्डन के सामने खड़े हैं।"
गार्डन -> शो लोक ++ " \ n " ++ "आप गार्डन में हैं। गार्डन बहुत अच्छी तरह से दिखता है: साफ, पतला, ठंडा और गीला। "
अन्यथा -> "" ++ शो लोक ++ " नाम के साथ स्थान के लिए कोई विवरण उपलब्ध नहीं है ।"

पहले से ही बेहतर है, हालांकि इन सभी प्लसस के साथ बहुत सारे काम जोड़े जा रहे हैं ... और दोहराने के लिए - खराब स्वाद ... एक सरल और अधिक सुरुचिपूर्ण तरीका है! अपने हाथ देखो:

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

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

* मुख्य : वर्णन घर
"होम \ n आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं।"
* मुख्य : putStrLn ( होम वर्णन करें )
घर
आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं ।

केस डिजाइन निश्चित रूप से अच्छा है। हालांकि, ऐसे मामले हैं जब यह असुविधाजनक है। यदि आपने पहले भाग से समस्या नंबर 2 को हल किया है, तो आप पहले से ही अनुमान लगा लेते हैं कि मेरा क्या मतलब है। आपको याद दिला दूं कि कुछ x और a के लिए निम्न फ़ंक्शन को लागू करना आवश्यक था:

  |  ln (abs (sin (x))) यदि x> 5
 य = |  x ^ 2 + a ^ 2 यदि x <= 5 और एक <= 3
     |  x / a + 7.8 * a if x <= 5 और a> 3 

फ़ंक्शन के रूप में, गणित में ऐसा अंधेरा। लेकिन अगर-और-या मामला का उपयोग करके हास्केल पर इसे लागू करने का प्रयास करें:

y x a = यदि x > 5
फिर लॉग ( पेट ( पाप ( x ) ) )
अन्यथा
यदि x <= 5 और& a <= 3
तब x ^ 2 + a ^ 2
और एक्स / ए + 7.8 * ए

y 'x a = case x > 5 का
सत्य -> लॉग ( पेट ( पाप ( x ) ) )
गलत -> मामला x <= 5 और& a <= 3 का
सच -> x ^ 2 + a ^ 2
मिथ्या -> x / a + 7.8 * a

कई स्तरों के घोंसले के कारण फ़ंक्शन को पढ़ना मुश्किल है। क्या वास्तव में कोई और रास्ता नहीं है? .. खैर, ऐसा कैसे! सुरक्षा भाव! और हास्केल फ़ंक्शन गणित में एक फ़ंक्शन की तरह हो जाता है। देखें:

y '' x a | x > 5 = लॉग ( पेट ( पाप ( x ) ) )
y '' x a | x <= 5 और& a <= 3 = x ^ 2 + a ^ 2
y '' x a | अन्यथा = x / a + 7.8 * a

- या एक ही बात:

y '' x a | x > 5 = लॉग ( पेट ( पाप ( x ) ) )
| x <= 5 और& a <= 3 = x ^ 2 + a ^ 2
| अन्यथा = x / a + 7.8 * a

यह समझना आसान है कि फ़ंक्शन "लॉग (पेट (पाप (x)))) लेता है" यदि x पाँच से अधिक है। एक गार्ड अभिव्यक्ति "के बीच एक अभिव्यक्ति है" | और "="। सुरक्षा अभिव्यक्तियों के लिए, वही नियम लागू होते हैं जो केस-निर्माण के विकल्प के लिए लागू होते हैं: अभिव्यक्ति का सेट पूरा होना चाहिए, अन्यथा यह हमेशा काम करता है।

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

0. हम खेल के माहौल की व्याख्या करते हैं:
- वर्तमान स्थान का विवरण प्रदर्शित करें;
- स्थान में वस्तुओं का विवरण प्रदर्शित करें।
1. हम खिलाड़ी से एक स्ट्रिंगर के रूप में टीम की प्रतीक्षा कर रहे हैं।
2. टीम को पहचानने की कोशिश करना।
3 ए। यदि कमांड मान्यता प्राप्त है:
- यह प्रदर्शन;
- हम बिंदु 0 पर लौटते हैं।
3 बी। यदि कमांड मान्यता प्राप्त नहीं है:
- इस बारे में एक संदेश जारी करें;
- हम बिंदु 1 पर लौटते हैं।

हाफ पॉइंट 0 तैयार है: यह "डिस्क्रिप्शनलास्ट" फंक्शन है। हमारे पास अभी तक कोई वस्तु नहीं है, हम उन्हें बाद में जोड़ देंगे। तो, चरण 1 पर जाएं। कीबोर्ड इनपुट कैसे प्राप्त करें? पहले भाग में, मैंने पुटस्ट्रॉन फ़ंक्शन के बारे में बात की, जो एक वास्तविक कंसोल में एक स्ट्रिंग प्रिंट करता है; यह विपरीत कार्य के साथ परिचित होने का समय है - गेटलाइन। निम्नलिखित मंत्र पर विचार करें:

दौड़ना =
करना
x <- गेटलाइन
putStrLn x

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

* मुख्य : रन
नमस्कार ! - मैंने क्या परिचय दिया
नमस्कार ! - क्या putStrLn फ़ंक्शन प्रिंट किया गया
* मुख्य : रन
kjljfs
kjljfs

एक बार फिर: getLine फ़ंक्शन प्रति पंक्ति के लिए पूछता है। स्ट्रिंग चर x के लिए बाध्य है, और अगले चरण में, putStrLn फ़ंक्शन प्रिंट x। चलो लाइन में प्रवेश करने से पहले "एंटर कमांड:" प्रॉम्प्ट जोड़कर स्पष्ट हो। उपयोगकर्ता को यह देखने दें कि वे उससे क्या चाहते हैं।

दौड़ना = करना
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
putStrLn x

* मुख्य : रन
कमांड दर्ज करें: देखो
देखो

मैंने putStr फ़ंक्शन का उपयोग किया: यह कुछ प्रिंट करता है, लेकिन कर्सर एक नई लाइन में अनुवाद नहीं करता है। सामान्य तौर पर, पास्कल के साथ एक पूर्ण सादृश्य है: writeLn <=> putStrLn, <=> StStr लिखें।

आप निश्चित रूप से, ध्यान दें कि मैंने "x के साथ संबद्ध" लिखा था, न कि "x असाइन करें"। हास्केल में कोई असाइनमेंट नहीं है, यही वजह है कि तीर ("<-") वहां खड़ा है, और असाइनमेंट साइन ("=", ": =") नहीं है। तीर से पता चलता है कि हमें परिणाम कहां से मिला है और हम इसे किससे जोड़ते हैं। विनियोग और बंधन के बीच दूरगामी परिणामों के साथ एक महत्वपूर्ण अंतर है। लेकिन जब तक हम इन परिणामों का उपयोग नहीं करते हैं, तब तक हमें चिंता नहीं करनी चाहिए।

अब हमें उपयोगकर्ता द्वारा दर्ज की गई कमांड को निष्पादित करने की आवश्यकता है। ऐसा करने के लिए, हम एक सरल कार्य "इवैल्यूएशन" के साथ आते हैं और इसे रन से कॉल करते हैं:

evalAction :: स्ट्रिंग -> स्ट्रिंग
evalAction strAct = "क्रिया:" ++ strAct ++ "!"

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

- परीक्षण:

* मुख्य : रन
कमांड दर्ज करें: देखो
"कार्रवाई: देखो!"
* मुख्य : रन
कमांड दर्ज करें: छोड़ें
"कार्रवाई: छोड़ो!"

हो हो हमारे खाली, कोई संदेह नहीं है, काम करता है! केवल अब, evalAction एक स्ट्रिंग लेता है, विशेष क्रिया प्रकार नहीं। इस वजह से, हम किसी भी अब्रकदबरा को एक समारोह में पास कर सकते हैं।

* मुख्य : रन
एंटर कमांड: lubaya _ abrakadabra
"कार्रवाई: lubaya_abrakadabra!"

हमें गुमराह किया जाता है। Lubaya_abrakadabra जैसी कोई कार्रवाई नहीं है ... हमने पहले ही किसी तरह वर्णन स्ट्रिंग समारोह में स्थान के साथ स्ट्रिंग को बदलने के साथ किया था। यदि हम इसे यहाँ दोहराते हैं तो क्या होगा? कार्रवाई के साथ लाइन बदलें:

evalAction :: एक्शन -> स्ट्रिंग
evalAction act = "Action:" ++ शो अधिनियम ++ "!"

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

ऐसा लगता है कि evalAction अच्छा लग रहा है: आप सिद्धांत रूप में जिबरिश पास नहीं कर सकते हैं, और निर्माणकर्ता को किसी भी तरह से संसाधित किया जाएगा, इस तरह के आदिम तरीके से। लेकिन यह कोड थोड़ा समस्याग्रस्त है: यह संकलन नहीं करता है।

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

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 46 : 38 :
वास्तविक प्रकार ' [ चार ] ' के साथ अपेक्षित प्रकार 'एक्शन' का मिलान नहीं हो सका
अपेक्षित प्रकार : लड़ाई
वास्तविक प्रकार : स्ट्रिंग
'वाष्पीकरण' के पहले तर्क में , अर्थात् 'x'
' PutStrLn ' के पहले तर्क में , जिसका नाम है ' ( evalAction x ) '
विफल , मॉड्यूल लोड किया गया: कोई नहीं ।

जीएचसीआई हमें बताता है कि प्रकार मेल नहीं खाते हैं। निकासी समारोह एक एक्शन प्रकार चाहता है, न कि एक स्ट्रिंग। हमने यहां एक गलती की: "putStrLn (evalAction x)"। हे ... लेकिन ऐसा विचार एक अच्छा था! "

हास्केल में प्रोग्रामिंग करते समय, आप अक्सर टाइपिंग त्रुटियां देखेंगे। इसमें कुछ भी गलत नहीं है; वे कहते हैं कि किस स्थान पर विसंगति है, जो प्राप्त होने की उम्मीद थी (अपेक्षित प्रकार), और उन्हें वास्तव में क्या प्राप्त हुआ (वास्तविक रूप)। आप गलत कोड संकलित नहीं कर सकते। बहुत सारे रिफैक्टरिंग के साथ, कई दर्जन त्रुटियां हो सकती हैं, और इससे भी अधिक, और आपको उन सभी को ठीक करना होगा, एक, दूसरा, तीसरा ... जब अंततः त्रुटियां गायब हो जाती हैं, तो कोड सबसे अधिक संभावना काम करेगा जैसा कि आप उम्मीद करते हैं। और यह, मैं आपको बताता हूं, बहुत, बहुत अच्छा है!

स्ट्रिंग "x" से टाइप एक्शन का एक निर्माता प्राप्त करने के लिए, कई समाधान हैं। सबसे पहले, चलो ConvertStringToAction फ़ंक्शन के साथ आने का प्रयास करें। "तीन" के लिए प्रश्न: स्ट्रिंग का कार्य करने वाले फ़ंक्शन का प्रकार क्या होगा? यह स्पष्ट है!

ConvertStringToAction :: स्ट्रिंग -> कार्रवाई

सबसे आसान तरीका केस का उपयोग करना है। अंतिम विकल्प में, हम इसे सुरक्षित रूप से खेलते हैं और यदि कुछ होता है तो क्विट वापस करते हैं।

ConvertStringToAction :: स्ट्रिंग -> कार्रवाई
ConvertStringToAction str = केस स्ट्रगल ऑफ़
देखो -> देखो
"नया" -> नया
अन्यथा -> छोड़ो

रन फ़ंक्शन में evalAction कहते समय इसे सम्मिलित करना सबसे अच्छा है। इस तरह:

- हम कार्रवाई की प्रक्रिया करते हैं।
evalAction :: एक्शन -> स्ट्रिंग
evalAction act = "Action:" ++ शो अधिनियम ++ "!"

- स्ट्रिंग को एक्शन में बदलें
ConvertStringToAction :: स्ट्रिंग -> कार्रवाई
ConvertStringToAction str = केस स्ट्रगल ऑफ़
देखो -> देखो
"नया" -> नया
अन्यथा -> छोड़ो

- हमें कीबोर्ड इनपुट मिलता है, इसे एक्शन में बदलें, हैंडलर को कॉल करें, परिणाम प्रदर्शित करें।
दौड़ना = करना
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
putStrLn ( evalAction ( ConvertStringToAction x ) )

अब जांचें:

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

* मुख्य : रन
कमांड दर्ज करें: देखो
क्रिया: देखो !
* मुख्य : रन
कमांड दर्ज करें: dfdf
क्रिया: छोड़ो !

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

वैसे, विचार के लिए भोजन: ConvertStringToAction फ़ंक्शन को लिखने के दो और तरीके हैं। विवेचन, बिना विवरण के।

- गार्ड के भाव (गार्ड)
convertStringToAction ' :: स्ट्रिंग -> कार्रवाई
ConvertStringToAction 'str | str == "देखो" = देखो
| str == "नया" = नया
| अन्यथा = छोड़ो

- पैटर्न मिलान
ConvertStringToAction '' :: स्ट्रिंग -> कार्रवाई
ConvertStringToAction '' '' देखो '' = देखें
ConvertStringToAction '' "नया" = नया
ConvertStringToAction '' _ = छोड़ें

- gci में जाँच करें
* मुख्य : ConvertStringToAction ' "नया"
नई
* मुख्य : ConvertStringToAction '' "नया"
नई

"और क्या, बार-बार फ़ंक्शन के केस-निर्माण का विस्तार करने के लिए ConvertStringToAction? मैं वास्तव में नहीं चाहता ... "- निराशा किस तरह के नोटों की है? .. हास्केल एक आलसी भाषा है, और एक वास्तविक प्रोग्रामर को भी आलसी होना चाहिए ताकि अतिरिक्त कोड न लिखें जहां इसकी आवश्यकता नहीं है। मामले का विस्तार नहीं करना चाहते हैं? और नहीं! हम क्या करेंगे? तैयार हो जाओ! हम एक नया मंत्र सीख रहे हैं! रिकॉर्ड: "रीड टाइप क्लास , जिसमें रीड होता है और फ़ंक्शन पढ़ता है।" हम अपने सभी एडीटी प्रकारों को पढ़ते हैं और देखते हैं कि यह कहां जाता है।

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

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

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

पढ़ने के कार्य को महसूस करने के लिए, आइए घिसी में थोड़ा खेलें। तुलना के लिए दो उदाहरण:

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

* मुख्य : वर्णन वर्णन ( "होम" पढ़ें )
"होम \ n आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं।"

क्या निष्कर्ष निकाला जा सकता है? वर्णन वर्णन फ़ंक्शन परिवर्तित नहीं हुआ है, इसे अभी भी स्थान प्रकार की आवश्यकता है। पहले उदाहरण में, हम कंस्ट्रक्टर को पास करते हैं, और दूसरे में, हम इसे "होम" लाइन से प्राप्त करते हैं।

* मुख्य : वर्णन ( पढ़ें ( शो होम ) )
"होम \ n आप लकड़ी के टेबल पर बीच के कमरे में खड़े हैं।"

रीड फ़ंक्शन एक स्ट्रिंग लेता है और इसे उस प्रकार से पार्स करने की कोशिश करता है जो इस स्थान पर आवश्यक है। प्रकारों के बारे में कैसे पढ़ता है? वह उन्हें आसपास के भावों से ले जाता है। इस स्थिति में, वह देखता है कि ("होम" पढ़ें) डिस्क्लेमरेशन फ़ंक्शन का एक पैरामीटर है, और पैरामीटर प्रकार सख्ती से सेट है। ऐसे समय होते हैं जब प्रकार कहीं नहीं होता है, लेकिन बहुत कम ही होता है। एक सरल उदाहरण: यदि आप ghci में "रीड" होम कहते हैं, तो संकलक हमें नहीं समझेगा:

* मुख्य : "होम" पढ़ें

< इंटरैक्टिव > : 1 : 1 :
अड़चन प्रकार अस्पष्ट 'बाधा' में :
( पढ़ें 0 ) ' पढ़ ' के उपयोग से उत्पन्न
संभावित फिक्स: एक प्रकार का हस्ताक्षर जोड़ें जो इन प्रकार के चर को ठीक करता है
अभिव्यक्ति में: "होम" पढ़ें
'इट' के लिए एक समीकरण में: यह = "होम" पढ़ें

लेकिन हम एक विशेष प्रविष्टि का उपयोग करके स्पष्ट रूप से प्रकार निर्दिष्ट करके उसकी मदद कर सकते हैं:

* मुख्य : "होम" :: स्थान पढ़ें
घर
* मुख्य " पढ़ा " 5.5 " :: फ्लोट
5.5
* मुख्य : "ट्रू" :: बूल पढ़ें

जादू, है ना? ConvertStringToAction फ़ंक्शन में रीड को लागू करने से, हमें एक छोटा और अधिक कार्यात्मक कोड मिलता है।

- हम कार्रवाई की प्रक्रिया करते हैं।
evalAction :: एक्शन -> स्ट्रिंग
evalAction act = "Action:" ++ शो अधिनियम ++ "!"

- स्ट्रिंग को एक्शन में बदलें
ConvertStringToAction :: स्ट्रिंग -> कार्रवाई
ConvertStringToAction str = str पढ़ें

- हमें कीबोर्ड इनपुट मिलता है, इसे एक्शन में बदलें, हैंडलर को कॉल करें, परिणाम प्रदर्शित करें।
दौड़ना = करना
putStr "कमांड दर्ज करें:"
x <- गेटलाइन
putStrLn ( evalAction ( ConvertStringToAction x ) )

- gci में जाँच करें:
* मुख्य : रन
कमांड दर्ज करें: देखो
क्रिया: देखो !
* मुख्य : रन
कमांड दर्ज करें: छोड़ें
क्रिया: छोड़ो !

दुर्भाग्य से, रीड में एक महत्वपूर्ण कमी है: यदि हम अब्रकदबरा को पास करते हैं, तो हमें एक अपवाद मिलेगा, और कार्यक्रम समाप्त हो जाएगा।

* मुख्य : रन
कमांड दर्ज करें: अबरकदबरा
क्रिया: *** अपवाद: प्रस्तावना । पढ़े : नहीं

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

ConvertStringToAction :: स्ट्रिंग -> कार्रवाई
ConvertStringToAction str = केस के तार पढ़ता है
[ ( x , _ ) ] -> x
_ -> छोड़ो

* मुख्य : रन
कमांड दर्ज करें: अबरकदबरा
क्रिया: छोड़ो !

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

1. खोज की वस्तुओं और जांच कार्रवाई।
- ADT "ऑब्जेक्ट" बनाएं, वहां कोई भी वस्तु जोड़ें।
- एक फंक्शन DescriptionObject बनाएँ, जो ऑब्जेक्ट का विवरण देता है।
- एक फ़ंक्शन जांच बनाएं, जो उपयोगकर्ता को ऑब्जेक्ट के नाम के लिए पूछता है और इस ऑब्जेक्ट का विवरण प्रदर्शित करता है।

2. कार्यक्रम "गूंगा कैलकुलेटर"।
पूर्णांक ऑपरेशन "जोड़ें", "घटाना" और "गुणा करें" हैं।
एक प्रोग्राम लिखें जिसमें उपयोगकर्ता को एक पूर्णांक 1 की आवश्यकता होती है, फिर एक पूर्णांक ऑपरेशन की आवश्यकता होती है, फिर एक पूर्णांक 2 की आवश्यकता होती है। जब यह सब प्राप्त हो जाता है, तो प्रोग्राम को संख्याओं पर संबंधित ऑपरेशन करना चाहिए और परिणाम प्रदर्शित करना चाहिए।

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

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