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

घर का पश्चिम
आप एक सफेद घर के पश्चिम में एक खुले मैदान में खड़े बोर्ड के साथ खड़े हैं।
यहां एक छोटा मेलबॉक्स है।

> मेलबॉक्स खोलें
छोटा मेलबॉक्स खोलने से एक पत्रक का पता चलता है।

> पत्रक पढ़ें
(लिया)
ZORK करने के लिए आपका स्वागत है!

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

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

भाग 1
जिसमें हम हास्केल भाषा की सभी मूल बातें नहीं जान पाएंगे और खोज के लिए एक उपयोगी कार्य लिखेंगे।

तो, आप बहुत शुरुआत में, बंद दरवाजे के सामने खड़े हैं और आप मेलबॉक्स देखते हैं।

हास्केल को प्रोग्राम करने की ज्यादा जरूरत नहीं है। सबसे पहले, इच्छा। दुभाषिया और संकलक भी उपयोगी हो सकते हैं। हम जीएचसी कंपाइलर (ग्लासगो हास्केल कम्पिलर) को विंडोज के लिए हास्केल प्लेटफॉर्म के हिस्से के रूप में उपयोग करेंगे, क्योंकि यह सुविधाजनक है। (यदि आपके पास लिनक्स है, तो आपको किसी भी सलाह की आवश्यकता नहीं है - आप मुझसे बेहतर जानते हैं कि मुझे हर काम कैसे करना है।) स्थापना तुच्छ है: डाउनलोड और इंस्टॉल करें। स्थापना के बाद, ghci कमांड चलाएँ। यदि यह नहीं पाया जाता है, तो PATH में फ़ोल्डर "... \ Haskell Platform \ xyz0 \ bin \" जोड़ें। हास्केल कोड "* .एचएस" फाइलों में संग्रहित है। इसे HIDEIDE या नोटपैड ++ (जैसा मैं करता हूं) में लिखा जा सकता है। हास्केल प्लेटफ़ॉर्म स्थापित करने के बाद, * .hs फाइलें GHCi दुभाषिया से जुड़ी होंगी - और यह बहुत सुविधाजनक है, जैसा कि आप बाद में देखेंगे। आप हैकेज की सभी अच्छाई का एक विशाल भंडार भी डाउनलोड कर सकते हैं, और वहां आपको एक सरल गेम एडगेम मिल जाएगा। वह खुद लिखने में मेरे लिए एक प्रकार और संदर्भ बिंदु था।

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

* मुख्य : 4
4
* मुख्य : 2 + 4 - 7
- 1
* मुख्य : 9 / ( 2 * 5.0 )
0.9
* मुख्य ( - 1 ) + 4
3
* मुख्य : 7 == 7
यह सच है
* मुख्य - ५ > ०
झूठा

गणित के कार्य भी आपके लिए उपलब्ध हैं: पाप x, cos x, tan x, atan x, abs x।

* मुख्य : पाप 10 * पाप 10 + कॉस 10 * कॉस 10
1.0
* मुख्य : पाप ( 2 * cos 10 ) + tan 5
- 4.374758876543559

हास्केल एक केस-संवेदी भाषा है (जैसे C ++, जावा)। मुझे पता है कि आप हमेशा cOS फ़ंक्शन चाहते थे, लेकिन यह सामंजस्य नहीं है! केवल "कॉस" है।

* मुख्य ( cos ( cos 0.5 ) )
0.8026751006823349
* मुख्य - cos pi
- 1.0

यह सब अपेक्षित और समझ में आता है। pi एक फ़ंक्शन है जो नंबर pi को लौटाता है, इसमें कोई तर्क नहीं है। त्रिकोणमितीय कार्य एक तर्क प्राप्त करते हैं। कई तर्कों के साथ कार्यों के बारे में क्या? वाक्यविन्यास सरल है: पहले फ़ंक्शन का नाम, फिर तर्क। बिना किसी कोष्ठक, अल्पविराम या अर्धविराम के।

* मुख्य : logBase 2 2
1.0
* मुख्य : logBase ( पाप 2 ) 2
- 7.28991425837762

दूसरे उदाहरण में, पाप 2 को कोष्ठक में लपेटना महत्वपूर्ण है ताकि यह लॉगबेस फ़ंक्शन का # 1 तर्क हो। यदि ऐसा नहीं किया जाता है, तो दुभाषिया यह सोचेगा कि हमने तीन तर्क (पाप, 2, 2) को दो के बजाय logBase फ़ंक्शन में पास किया, और शपथ लेता है:

* मुख्य : logBase पाप 2 2

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

वह हमें क्या बताता है, हम इसके बारे में अभी तक नहीं सोचेंगे। यह एक शाही मामला नहीं है, हमारे पास अधिक महत्वपूर्ण मामले हैं।

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

शब्द :: स्ट्रिंग -> [ स्ट्रिंग ]

या यह भी एक:

Eq a => Eq ( शायद )

नहीं समझे? कुछ नहीं, हम इसका पता लगाएंगे।

हालांकि कुछ है, चलो थोड़ा खेलते हैं, केवल अब लाइनों के साथ। हास्केल तार सी के समान दिखते हैं: दोहरे उद्धरण के अंदर वर्ण। विशेष वर्ण \ n ("नई पंक्ति") भी काम करता है।

* मुख्य : "हैलो, दुनिया!"
"नमस्ते दुनिया!"
* मुख्य : "हैलो, \ n दुनिया!"
"नमस्ते, \ n दुनिया!"

क्या काम नहीं किया ?? A. जब हम ghci में एक पंक्ति लिखते हैं, तो वह इसे दोहराता है। इसी तरह, यह एक एकल संख्या या सही दोहराएगा:

* मुख्य : 1,000,000
1000000
* मुख्य - सत्य
यह सच है

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

* मुख्य : putStrLn "हैलो, \ n दुनिया!"
हैलो,
दुनिया !

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

* मुख्य : putStrLn ( "हैलो, दुनिया!" ++ " \ n यहाँ हम चलते हैं!"
नमस्ते दुनिया !
यहाँ हम चले !

कोष्ठक की आवश्यकता होती है ताकि घी हमें सही मिले। कोष्ठक के बिना, वह सचमुच निम्नलिखित सोचेंगे:
putStrLn "हैलो, दुनिया!" ++ "\ n कैसे हम चलते हैं!" <=> (putStrLn "नमस्कार, दुनिया!") ++ ("\ n कैसे हम चलते हैं!"
और यह एक घात है, क्योंकि हम कंसोल string1 जोड़ने string2 को जोड़ने की कोशिश कर रहे हैं। हम आउटपुट में एक स्ट्रिंग कैसे जोड़ सकते हैं ?? यहाँ दुरुपयोग क्या है:

* मुख्य : putStrLn "हैलो, दुनिया!" ++ " \ n यहाँ हम चलते हैं!"

< इंटरैक्टिव > : 1 : 1 :
वास्तविक प्रकार ' IO ( ) ' के साथ अपेक्षित प्रकार [a ] को मेल नहीं कर सका
' PutStrLn ' के कॉल के रिटर्न प्रकार में
पहले तर्क में ' ( ++ ) ' , अर्थात्
' putStrLn "हैलो, दुनिया!"
अभिव्यक्ति में: putStrLn "हैलो, दुनिया!" ++ " \ n यहाँ हम चलते हैं!"

कंसोल के लिए दो आउटपुट भी जोड़ नहीं है। कुछ और गलत विकल्प:

* मुख्य : putStrLn "हैलो, दुनिया!" ++ putStrLn " \ n यहाँ हम चलते हैं!"
* मुख्य : putStrLn "हैलो, दुनिया!" PutStrLn " \ n यहाँ हम चलते हैं!"
* मुख्य : "हैलो, दुनिया!" ++ putStrLn " \ n यहाँ हम चलते हैं!"

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

* मुख्य : "नमस्ते, दुनिया!" ++ " \ n यहाँ हम चलते हैं!"
“नमस्ते दुनिया! \ n यहाँ हम चलते हैं! "

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

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

* मुख्य : putStrLn 5

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

आप किसी चीज के बारे में दुभाषिए की परिचित कसम खाते हैं। PutStrLn फ़ंक्शन एक स्ट्रिंग (स्ट्रिंग प्रकार) चाहता है, और केवल यह, लेकिन एक संख्या प्राप्त करता है। प्रकार मेल नहीं खाते, => एक संघर्ष है। आप यह कर सकते हैं:

* मुख्य : putStrLn ( शो 5 )
5

शो फ़ंक्शन, यदि संभव हो, तो तर्क को एक स्ट्रिंग में परिवर्तित करता है, जिसे बाद में पुटस्ट्रॉन का उपयोग करके मुद्रित किया जाता है। यह सुनिश्चित करने के लिए कि जब आप फ़ंक्शन निष्पादित करते हैं (शो 5), तो आपको स्ट्रिंग "5" मिलती है, कुछ इस तरह दर्ज करें:

* मुख्य : putStrLn ( "स्ट्रिंग और" ++ ( शो 5 ) ++ " \ n - फिर से एक स्ट्रिंग।"
स्ट्रिंग और ५
- फिर से एक स्ट्रिंग ।

शो फ़ंक्शन एक स्ट्रिंग में कई प्रकारों का अनुवाद कर सकता है। वह खोज में बहुत उपयोगी होगा।

* मुख्य : putStrLn ( "पाप ^ 2 5 + cos ^ 2 5 =" ++ शो ( पाप 5 * पाप 5 + cos 5 * cos 5 ) )
sin ^ 2 5 + cos ^ 2 5 = 0.9999999999999999

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

* मुख्य: टी 3 == 3
3 == 3 :: बूल
* मुख्य: टी 3 / = 3
3 / = 3 :: बूल
* मुख्य: प्रकार 'च'
'च' :: चार
* मुख्य: प्रकार "मैं एक स्ट्रिंग हूँ"
"मैं एक स्ट्रिंग हूँ" :: [ चार ]

यहां, किसी भी अभिव्यक्ति को एक विशेष प्रकार का फ़ंक्शन माना जा सकता है, संभवतः पैरामीटर नहीं ले रहा है, लेकिन आवश्यक रूप से एक परिणाम लौटा रहा है। PutStrLn फ़ंक्शन प्रकार इस तरह दिखता है:

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

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

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

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

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

ठेस x y = x * y

असाइनमेंट के बारे में भूल जाओ! हास्केल में कोई असाइनमेंट नहीं है! जो आप ऊपर देख रहे हैं वह एक फ़ंक्शन घोषणा है। "समान" का अर्थ है कि ठेस दो तर्कों x और y के साथ कार्य करती है, हम अभिव्यक्ति x * y से मेल खाते हैं। यदि हम फ़ंक्शन को कॉल करते हैं तो इस अभिव्यक्ति का मूल्यांकन किया जाएगा। चलो करते हैं। QuestMain.hs फ़ाइल सहेजें। यदि आपने पहले से ही ghci कंसोल को बंद कर दिया है, तो इसे फिर से चलाएँ (ghci QuestMain.hs)। यदि कंसोल खुला है, तो कमांड दर्ज करें: r - यह ghci को वर्तमान फ़ाइल को रिबूट करने और संकलित करने के लिए मजबूर करेगा, अर्थात आपका QuestMain.hs।

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

यह काम करता है! (यदि यह काम नहीं करता है, तो जांच करें: पत्र का मामला; क्या QuestMain.hs बच गया है; क्या यह संस्करण ghci में लोड है?) यह अनुमान लगाना आसान है कि संख्या 3 और 5 क्रमशः चर x और y के साथ जुड़े हुए हैं। दुभाषिया 3 * 5 की अभिव्यक्ति के साथ 3 5 को प्रतिस्थापित करता है, जिसकी गणना की जाती है।

* मुख्य : ठेस 3 ( 2 + 3 )
15
* मुख्य : ठेस 3 ( cos pi )
- 3.0

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

PrintString str = putStrLn str
PrintSqrt x = putStrLn ( "Sqrt of" ++ शो x ++ "=" ++ शो ( वर्ग x ) )

* मुख्य : प्रिंटस्ट्रिंग "dfdf"
dfdf
* मुख्य : PrintSqrt 4
4.0 = 2.0 का Sqrt
* मुख्य : PrintSqrt ( - 4 )
Sqrt of - 4.0 = NaN

उत्तरार्द्ध मामले में, एक ऋणात्मक संख्या का वर्गमूल परिणाम "नहीं संख्या" देता है। मान लीजिए कि यह निष्कर्ष हमें शोभा नहीं देता है, और हम स्ट्रिंग "x <0!" को नकारात्मक x में आउटपुट करना चाहेंगे। हम कई तरीकों से प्रिंटस्कर्ट फ़ंक्शन को फिर से लिखते हैं, और एक ही समय में बहुत उपयोगी निर्माणों के एक जोड़े का अध्ययन करते हैं।

PrintSqrt1 x =
यदि x < 0
फिर पुटस्ट्रन "x <0!"
और पुटस्ट्रल ( "Sqrt of" ++ शो x ++ "=" ++ शो ( sqrt x ) )

PrintSqrt2 x = case x < 0 का
सच -> putStrLn "x <0!"
गलत -> putStrLn ( "Sqrt of" ++ शो x ++ "=" ++ शो ( sqrt x ) )

* मुख्य : PrintSqrt1 ( - 4 )
x < ० !
* मुख्य - PrintSqrt2 ( - 4 )
x < ० !

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

PrintSqrt2 x = case x < 0 का
सच -> putStrLn "x <0!"

* मुख्य: आर
...
* मुख्य - PrintSqrt2 ( - 4 )
x < ० !
* मुख्य : PrintSqrt2 10
*** अपवाद: H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: ( 12 , 16 ) - ( 13 , 41 ) : मामले में गैर - थकाऊ पैटर्न

यह भी ध्यान दें कि मामले में निर्माण, इंडेंटेशन ("इंडेंटेशन") महत्वपूर्ण है। उन्हें समान होना चाहिए - यह वहाँ या टैब पर भी लागू होता है। संकलन का प्रयास करें:

PrintSqrt2 x = case x < 0 का
सच -> putStrLn "x <0!"
गलत -> putStrLn ( "Sqrt of" ++ शो x ++ "=" ++ शो ( sqrt x ) )

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

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 14 : 23 :
इनपुट पर त्रुटि ' -> '
विफल , मॉड्यूल लोड किया गया: कोई नहीं ।

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

thinkAboutSquaredX x = केस x
0.0 -> "मुझे लगता है, x 0 है, क्योंकि 0 * 0 = 0."
1.0 -> "x 1 है, क्योंकि 1 * 1 = 1."
4.0 -> "ठीक है, x 2 है, क्योंकि 2 * 2 = 4."
9.0 -> "x = 3."
16.0 -> "कोई रास्ता नहीं, x = 4."
25.0 -> "हा! एक्स = 5!"
अन्यथा -> यदि x < 0 तो "x <0!" वरना "Sqrt" ++ शो x ++ "=" ++ शो ( sqrt x )

* मुख्य : thinkAboutSquaredX 1
"X 1 है, क्योंकि 1 * 1 = 1."
* मुख्य : thinkAboutSquaredX 25
«हा! x = 5! ”

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

thinkAboutSquaredX x = केस x
0.0 -> "मुझे लगता है, x 0 है, क्योंकि 0 * 0 = 0."
1.0 -> "x 1 है, क्योंकि 1 * 1 = 1."
अन्यथा -> अगर x < 0 तो "x <0!" और "Sqrt" ++ शो x ++ "=" ++ शो ( sqrt x )
4.0 -> "ठीक है, x 2 है, क्योंकि 2 * 2 = 4."
9.0 -> "x = 3."
16.0 -> "कोई रास्ता नहीं, x = 4."
25.0 -> "हा! x = 5! ”

कोड संकलित करता है, लेकिन हमें मिलान के लिए नमूनों के प्रतिच्छेदन के बारे में चेतावनी मिलती है:

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

H: \ Haskell \ QuestTutorial \ क्वेस्ट \ QuestMain । hs: 16 : 24 :
चेतावनी: पैटर्न मैच ( तों ) ओवरलैप किए गए हैं
एक मामले में विकल्प:
4.0 -> ...
9.0 -> ...
16.0 -> ...
25.0 -> ...
ठीक है , मॉड्यूल लोड किए गए: मुख्य ।
* मुख्य : thinkAboutSquaredX 1
"X 1 है, क्योंकि 1 * 1 = 1."
* मुख्य : thinkAboutSquaredX 9
"Sqrt 9.0 = 3.0"
* मुख्य: टी अन्यथा
अन्यथा :: बूल
* मुख्य = अन्यथा == सच
यह सच है

याद करें कि हम यहां क्या कर रहे हैं: हम एक खोज लिख रहे हैं! किसी भी खोज में तीन चीजें होती हैं: स्थान (पथों को हिलाने से), वस्तुएं और खिलाड़ी की क्रियाएं। यदि हमारे पास इसकी संख्या हो तो हम स्थान का विवरण कैसे प्राप्त कर सकते हैं? यहाँ समाधान है:

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

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

कृपया ध्यान दें: टिप्पणी! सिंगल-लाइन टिप्पणियां डबल माइनस (एसक्यूएल के रूप में!) से शुरू होती हैं। बहु-पंक्ति वर्णों के लिए {- और -} का उपयोग किया जाता है:

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

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

समेकित करने के लिए, आप निम्नलिखित कार्यों को हल कर सकते हैं:

1. फ़ंक्शन z को परिभाषित करें और कुछ मानों के लिए इसकी गणना करें:
t = (7 * x ^ 3 - ln (abs (a)) / (2.7 * b)
y = sin (t) - sin (a)
z = 8.87 * y ^ 3 + आर्कटिक (टी)
जहाँ x, a, b प्रकार फ़्लोट के चर हैं।

2. फ़ंक्शन y को परिभाषित करें और कुछ मानों के लिए इसकी गणना करें:
| ln (abs (sin (x))) यदि x> 5
य = | x ^ 2 + a ^ 2 यदि x <= 5 और एक <= 3
| x / a + 7.8 * a if x <= 5 और a> 3
जहां x, एक प्रकार का चर हैं।

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