कांटों के माध्यम से हास्केल। 1/2

हास्केल के संक्षिप्त और कठिन परिचय का पहला भाग। दूसरा भाग यहाँ पाया जा सकता है।

tl; dr : हास्केल का संक्षिप्त और संक्षिप्त परिचय।

• परिचय
  
  • स्थापना
  • कोई घबराहट नहीं
  • हास्केल की मूल बातें
    
    • समारोह घोषणा
    • उदाहरण प्रकार का उपयोग करना
    
    
  
  
• हास्केल से आवश्यक न्यूनतम
  
  • भाव
    
    • अंकगणित
    • पहेली
    • पेचीदगी
    • सूचियों
    • पंक्तियां
    • tuples
    • हम कोष्ठक से निपटते हैं
    
    
  • कार्यों को लिखने के लिए उपयोगी चीजें
  
  
• कठिन हिस्सा
  
  • क्रियात्मक शैली
    
    • उच्च आदेश कार्य
    
    
  • प्रकार
    
    • प्रकार का अनुमान
    • नए प्रकार बनाना
    • पुनरावर्ती प्रकार
    • पेड़
    
    
  • अंतहीन संरचनाएं
  
  

युपीडी। यदि आपको ट्यूटोरियल पसंद आया है, तो मूल लेख के लेखक को कुछ पंक्तियाँ छोड़ें। व्यक्ति प्रसन्न होगा;)

मेरा वास्तव में मानना ​​है कि हर डेवलपर को हास्केल सीखना चाहिए। मुझे नहीं लगता कि हर किसी को सुपर हास्केल-निंजा होना चाहिए। लोगों को बस उन अवसरों के बारे में पता होना चाहिए जो हास्केल प्रदान करता है। हास्केल सीखना आपकी चेतना का विस्तार करता है।


मुख्यधारा की भाषाएँ बहुत समान हैं

• चर
• चक्र
• संकेत (भले ही अधिकांश भाषाएँ इस तथ्य को छिपाने की कोशिश करें, यह अभी भी एक तथ्य है)
• संरचनाएं, वस्तुएं और कक्षाएं (अधिकांश भाषाओं में)

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


लेकिन हास्केल सीखना मुश्किल हो सकता है। कम से कम मेरे लिए यह मुश्किल था। और इस लेख में मैं यह दिखाने की कोशिश करूंगा कि मुझे अध्ययन की प्रक्रिया में क्या कमी थी।

यह लेख मास्टर करना मुश्किल होगा। यह उद्देश्य पर किया गया था। हास्केल सीखने के लिए कोई आसान तरीके नहीं हैं। यह सड़क मुश्किल और मुश्किल है। लेकिन मुझे लगता है कि यह अच्छा है। क्योंकि यह हास्केल की जटिलता है जो इसे दिलचस्प बनाती है।

हास्केल सीखने का सामान्य तरीका दो किताबें पढ़ना है।
सबसे पहले, "आप एक हास्केल सीखें" , और फिर "रियल वर्ल्ड हास्केल" ।

मैं मानता हूं कि यह सीखने का सही तरीका है। लेकिन हास्केल क्या है, यह समझने के लिए, आपको इन पुस्तकों को बहुत सावधानी से पढ़ना होगा।


दूसरी ओर, यह लेख हास्केल के सभी बुनियादी पहलुओं का एक बहुत ही संक्षिप्त और संक्षिप्त परिचय है। मैंने कुछ बारीकियों को भी जोड़ा जो हस्केल का अध्ययन करते समय याद आ रही थीं।


लेख में पाँच भाग शामिल हैं:

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

नोट: हर बार जब आप फ़ाइल नाम और .lhs एक्सटेंशन के साथ एक सीमांकक देखते हैं,
आप इसे डाउनलोड कर सकते हैं।
यदि आप फ़ाइल को filename.lhs रूप में सहेजते हैं। तो, आप इसे चला सकते हैं
runhaskell फ़ाइल नाम। lhs


कुछ उदाहरण काम नहीं कर सकते हैं, लेकिन अधिकांश को करना चाहिए।
नीचे आपको फ़ाइल का लिंक देखना चाहिए

---

01_basic / 10_Introduction / 00_hello_world.lhs

परिचय

स्थापना

• हास्केल प्लेटफार्म हास्केल को स्थापित करने का मानक तरीका है।

उपयोगिताएँ:

• ghc : C लिए gcc के समान एक संकलक C
• ghci : हास्केल इंटरेक्टिव शेल (REPL)
• runhaskell : इसे संकलित किए बिना एक प्रोग्राम चलाएं। संकलित कार्यक्रमों की तुलना में सुविधाजनक, लेकिन बहुत धीमी गति से।

कोई घबराहट नहीं

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

 main = putStrLn "Hello World!" 

इसे चलाने के लिए, इस कोड को hello.hs के रूप में hello.hs और चलाएँ:

  ~ runhaskell ./hello.hs Hello World! 

आप "परिचय" के तहत स्थित लिंक से स्रोत डाउनलोड कर सकते हैं

फ़ाइल को सहेजें 00_hello_world.lhs और निष्पादित करें:

  ~ runhaskell 00_hello_world.lhs Hello World! 

01_basic / 10_Introduction / 00_hello_world.lhs

---

01_basic / 10_Introduction / 10_hello_you.lhs

और अब हम एक प्रोग्राम लिखेंगे जो आपका नाम पूछेगा और कहेगा "हैलो, नाम!"

 main = do print "  ?" name <- getLine print (" " ++ name ++ "!") 

शुरू करने के लिए, अन्य अनिवार्य भाषाओं के साथ हमारे उदाहरण की तुलना करें:

 # Python print "  ?" name = raw_input() print " %s!" % name 

 # Ruby puts "  ?" name = gets.chomp puts " #{name}!" 

 // In C #include <stdio.h> int main (int argc, char **argv) { char name[666]; // <-  ! //  ,     665 ? printf("  ?\n"); scanf("%s", name); printf(" %s!\n", name); return 0; } 

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


हास्केल में, प्रत्येक फ़ंक्शन और ऑब्जेक्ट का अपना प्रकार होता है।
main कार्य का प्रकार IO () ।
इसका मतलब यह है कि जब निष्पादित किया जाता है, तो main दुष्प्रभाव पैदा करता है।

लेकिन यह मत भूलो कि हास्केल एक सामान्य अनिवार्य भाषा की तरह दिख सकती है।

01_basic / 10_Introduction / 10_hello_you.lhs

---

01_basic / 10_Introduction / 20_very_basic.lhs

सबसे बुनियादी हास्केल

इससे पहले कि हम जारी रखें, मैं आपको हास्केल की कुछ विशेष विशेषताओं के बारे में चेतावनी देना चाहूंगा।

कार्यक्षमता

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

उन्नत स्थैतिक टाइपिंग

C , C++ या Java में अपने तरीके से खड़े होने के बजाय, टाइप सिस्टम आपकी मदद करेगा।

पवित्रता

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


इसके अलावा, कार्यात्मक रूप से शुद्ध कार्य बुनियादी हास्केल कानून का पालन करते हैं:

एक ही पैरामीटर के साथ एक फ़ंक्शन कॉल हमेशा एक ही परिणाम देता है।

ढिलाई

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

आखिरी चेतावनी चिंता करेगी कि हास्केल पर कोड को पढ़ने के लायक कैसे है।
मेरे लिए, यह वैज्ञानिक लेख पढ़ने की तरह है।
कुछ भाग सरल और स्पष्ट हो सकते हैं, लेकिन यदि आप सूत्र देखते हैं, तो ध्यान केंद्रित करें और अधिक धीरे-धीरे पढ़ें।
हास्केल सीखते समय, यदि आप कुछ सिंटैक्स विशेषताओं को पूरी तरह से नहीं समझते हैं तो यह वास्तव में महत्वपूर्ण नहीं है।
यदि आप >>= , <$> , <- या अन्य डरावने पात्रों के साथ आते हैं, तो उन्हें अनदेखा करें और कोड के सामान्य विचार को समझने की कोशिश करें।

कार्य की परिभाषा

आप निम्न प्रकार से कार्यों को परिभाषित कर सकते हैं:

C :

 int f(int x, int y) { return x*x + y*y; } 

जावास्क्रिप्ट में:

 function f(x,y) { return x*x + y*y; } 

पायथन में:

 def f(x,y): return x*x + y*y 

रूबी पर:

 def f(x,y) x*x + y*y end 

योजना पर:

 (define (fxy) (+ (* xx) (* yy))) 

और अंत में, हास्केल:

 fxy = x*x + y*y 

बहुत स्पष्ट है। कोई कोष्ठक नहीं, कोई def नहीं।

याद रखें कि हास्केल कार्यों और प्रकारों का भारी उपयोग करता है।
और इसलिए उनकी पहचान करना बहुत आसान है।
भाषा वाक्य रचना को यथासंभव सरल बनाने के लिए सोचा गया था।

एक नया प्रकार बनाने का उदाहरण

आमतौर पर प्रोग्राम लिखते समय, आप फ़ंक्शन के प्रकार को इंगित करते हैं।
लेकिन यह आवश्यक नहीं है।
कंपाइलर आपके लिए ऐसा करने के लिए पर्याप्त स्मार्ट है।

चलो थोड़ा खेलते हैं।

 --     :: f :: Int -> Int -> Int fxy = x*x + y*y main = print (f 2 3) 

 ~ runhaskell 20_very_basic.lhs 13 

01_basic / 10_Introduction / 20_very_basic.lhs

---

01_basic / 10_Introduction / 21_very_basic.lhs

अब कोशिश करो

 f :: Int -> Int -> Int fxy = x*x + y*y main = print (f 2.3 4.2) 

आपको त्रुटि मिलेगी:

 21_very_basic.lhs:6:23: No instance for (Fractional Int) arising from the literal `4.2' Possible fix: add an instance declaration for (Fractional Int) In the second argument of `f', namely `4.2' In the first argument of `print', namely `(f 2.3 4.2)' In the expression: print (f 2.3 4.2) 

समस्या यह है कि 4.2 इंट नहीं है।

01_basic / 10_Introduction / 21_very_basic.lhs

---

01_basic / 10_Introduction / 22_very_basic.lhs

एक समाधान फ़ंक्शन के प्रकार को स्पष्ट रूप से इंगित नहीं करना होगा।
तब हास्केल हमारे लिए सबसे सामान्य प्रकार के लिए कटौती करेगा:

 fxy = x*x + y*y main = print (f 2.3 4.2) 

जीत गए हैं!
महान, हमें प्रत्येक डेटा प्रकार के लिए एक नया फ़ंक्शन बनाने की आवश्यकता नहीं है।
उदाहरण के लिए, C , आपको int लिए एक फ़ंक्शन बनाने की आवश्यकता होगी, float , long , double , आदि।

लेकिन हमें किस प्रकार का संकेत देना चाहिए?
यह समझने के लिए कि हस्केल ने हमारे लिए किस प्रकार की कटौती की है, बस ghci चलाएं:

 % ghci GHCi, version 7.0.4: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Loading package ffi-1.0 ... linking ... done. Prelude> let fxy = x*x + y*y Prelude> :type f f :: Num a => a -> a -> a 

हम्म ... यह किस प्रकार का अजीब है?

 Num a => a -> a -> a 

सबसे पहले a -> a -> a के दाईं ओर ध्यान दें।
इसे समझने के लिए, आइए कुछ उदाहरण देखें:

निर्दिष्ट प्रकार	मूल्य
Int	Int लिखें
Int -> Int	फ़ंक्शन जो इनपुट Int लेता है और Int रिटर्न करता है
Float -> Int	फ़ंक्शन जो Float स्वीकार करता है और Int वापस करता है
a -> Int	फंक्शन का प्रकार जो इनपुट के रूप में किसी भी प्रकार को लेता है और Int देता है
a -> a	फ़ंक्शन का प्रकार जो इनपुट प्रकार लेता a और एक प्रकार का एक परिणाम देता a
a -> a -> a	फ़ंक्शन का प्रकार a इनपुट के रूप में टाइप के दो तर्क लेता है और प्रकार का एक परिणाम देता a

A a -> a -> a , अक्षर a एक प्रकार का चर है ।
इसका मतलब है कि f दो तर्कों का एक फ़ंक्शन है, और दोनों तर्क, साथ ही परिणाम, एक ही प्रकार के हैं।
प्रकार का एक चर विभिन्न प्रकारों के मूल्यों को ले सकता है।
उदाहरण के लिए Int , Integer , Float ...

इसलिए हार्ड सेटिंग के बजाय, जैसे कि C और अलग से int , long , float , double , आदि के लिए फ़ंक्शंस को परिभाषित करना ...
हम बस एक फ़ंक्शन बनाते हैं, जैसा कि डायनामिक रूप से टाइप की गई भाषा में।

सामान्यतया, किसी भी प्रकार का हो सकता है।
String , Int , अधिक जटिल प्रकार जैसे Trees , एक अन्य फ़ंक्शन प्रकार, आदि के साथ।
लेकिन हमारे उदाहरण में, प्रकार में उपसर्ग Num a => ।

Num एक प्रकार है ।
एक प्रकार के वर्ग को कई प्रकारों के रूप में दर्शाया जा सकता है।
Num केवल प्रकार शामिल होते हैं जो संख्याओं की तरह व्यवहार करते हैं।
अधिक सख्ती से, Num एक प्रकार से युक्त एक वर्ग है जो विशेष रूप से (+) और (*) कार्यों के दिए गए सेट को लागू करता है।

टाइप कक्षाएं भाषा का एक बहुत शक्तिशाली तत्व हैं।
उनकी मदद से हम कमाल कर सकते हैं।
लेकिन हम इस बारे में थोड़ी देर बाद बात करेंगे।

अतः, Num a => a -> a -> a मतलब लिखना

आज्ञा देना a प्रकार से संबंधित a प्रकार है।
यह एक फ़ंक्शन है जो इनपुट के रूप में लेता है और रिटर्न ( a -> a )।

हम्म, यह अजीब है।
वास्तव में, हास्केल में, कोई फ़ंक्शन इनपुट के रूप में दो तर्कों को स्वीकार नहीं करता है।
इसके बजाय, सभी कार्यों में केवल एक तर्क है।
लेकिन ध्यान दें कि दो तर्कों के एक फ़ंक्शन को एक फ़ंक्शन के रूप में दर्शाया जा सकता है जो पहले तर्क लेता है और एक फ़ंक्शन देता है जो दूसरे तर्क को एक पैरामीटर के रूप में लेता है।
।

अर्थात, f 3 4 (f 3) 4 बराबर है।
ध्यान दें कि f 3 भी एक फ़ंक्शन है:

 f :: Num a :: a -> a -> a g :: Num a :: a -> a g = f 3 gy ⇔ 3*3 + y*y 

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

 g = \y -> 3*3 + y*y 

\ वर्ण का उपयोग किया जाता है क्योंकि यह λ चरित्र जैसा दिखता है, लेकिन एक ही समय में, यह एक ASCII वर्ण है।

यदि कार्यात्मक प्रोग्रामिंग आपके लिए नया है, तो इस बिंदु पर आपके दिमाग में उबाल आना शुरू हो जाता है।
वास्तविक आवेदन लिखने का समय आ गया है।

01_basic / 10_Introduction / 22_very_basic.lhs

---

01_basic / 10_Introduction / 23_very_basic.lhs

लेकिन इससे पहले कि हम शुरू करें, हमें यह सत्यापित करने की आवश्यकता है कि टाइप सिस्टम उसी तरह काम करता है जैसे:

 f :: Num a => a -> a -> a fxy = x*x + y*y main = print (f 3 2.4) 

यह कोड काम करता है क्योंकि 3 प्रकार के अस्थायी (आंशिक) संख्या का प्रतिनिधित्व कर सकता है फ्लोट की संख्या और पूर्णांक प्रकार का पूर्णांक।
चूँकि 2.4 भिन्नात्मक प्रकार का है, इसलिए 3 भिन्नात्मक संख्या के रूप 3 भी दर्शाया गया है।

01_basic / 10_Introduction / 23_very_basic.lhs

---

01_basic / 10_Introduction / 24_very_basic.lhs

यदि हम फ़ंक्शन में अन्य प्रकार लिखते हैं, तो यह काम करना बंद कर देगा:

 f :: Num a => a -> a -> a fxy = x*x + y*y x :: Int x = 3 y :: Float y = 2.4 main = print (fxy) --   ,   x ≠  y 

कंपाइलर एक त्रुटि का संकेत देता है।
दो पैरामीटर एक ही प्रकार के होने चाहिए।

यदि आपको लगता है कि यह एक बुरा विचार है, और संकलक को आपके लिए प्रकार परिवर्तित करना चाहिए, तो आपको वास्तव में एक शानदार और मजेदार वीडियो देखना चाहिए:
WAT

01_basic / 10_Introduction / 24_very_basic.lhs

हास्केल न्यूनतम आवश्यक

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

मैं दो भावों की समानता दिखाने के लिए प्रतीक ⇔ का उपयोग करूंगा।
यह एक मेटा-संकेतन है; हास्केल में कोई नहीं है।
एक अभिव्यक्ति का मूल्यांकन करने के परिणाम को इंगित करने के लिए प्रतीक ⇒ का उपयोग किया जाएगा।

भाव

अंकगणित

 3 + 2 * 6 / 3 ⇔ 3 + ((2*6)/3) 

पहेली

 True || False ⇒ True True && False ⇒ False True == False ⇒ False True /= False ⇒ True (/=)     

पेचीदगी

 x^n   n (Int  Integer) x**y    y ( Float) 

मशीन की रैम के अपवाद के साथ Integer की कोई आकार सीमा नहीं है:

 4^103 102844034832575377634685573909834406561420991602098741459288064 

अरे हाँ!
और आप तर्कसंगत संख्याओं का उपयोग कर सकते हैं!
लेकिन इसके लिए आपको Data.Ratio मॉड्यूल का उपयोग करना Data.Ratio :

 $ ghci .... Prelude> :m Data.Ratio Data.Ratio> (11 % 15) * (5 % 3) 11 % 9 

सूचियों

 [] ⇔   [1,2,3] ⇔    ["foo","bar","baz"] ⇔   (String) 1:[2,3] ⇔ [1,2,3], (:)    1:2:[] ⇔ [1,2] [1,2] ++ [3,4] ⇔ [1,2,3,4], (++)   [1,2,3] ++ ["foo"] ⇔  String ≠ Integral [1..4] ⇔ [1,2,3,4] [1,3..10] ⇔ [1,3,5,7,9] [2,3,5,7,11..100] ⇔ !    ! [10,9..1] ⇔ [10,9,8,7,6,5,4,3,2,1] 

पंक्तियां

हास्केल में, तार Char की एक सूची है।

 'a' :: Char "a" :: [Char] "" ⇔ [] "ab" ⇔ ['a','b'] ⇔ 'a':"b" ⇔ 'a':['b'] ⇔ 'a':'b':[] "abc" ⇔ "ab"++"c" 

नोट :
वास्तविक कार्यों में, आप पाठ के साथ काम करने के लिए वर्णों की एक सूची का उपयोग नहीं करेंगे।
ज्यादातर मामलों में, इसके लिए Data.Text उपयोग किया जाता है।
यदि आपको ASCII वर्णों की एक धारा के साथ काम करने की आवश्यकता है, तो आपको Data.ByteString उपयोग करना चाहिए।

tuples

आप एक जोड़ी को निम्नानुसार निर्दिष्ट कर सकते हैं (a,b) ।
एक टपल के तत्व विभिन्न प्रकार के हो सकते हैं।

 --    -  (2,"foo") (3,'a',[2,3]) ((2,"a"),"c",3) fst (x,y) ⇒ x snd (x,y) ⇒ y fst (x,y,z) ⇒ ERROR: fst :: (a,b) -> a snd (x,y,z) ⇒ ERROR: snd :: (a,b) -> b 

हम कोष्ठक से निपटते हैं

अतिरिक्त कोष्ठक से छुटकारा पाने के लिए, आप इन कार्यों का उपयोग कर सकते हैं: ($) और (.) ।

 --  : fghx ⇔ (((fg) h) x) -- $    $ --    fg $ hx ⇔ fg (hx) ⇔ (fg) (hx) f $ ghx ⇔ f (ghx) ⇔ f ((gh) x) f $ g $ hx ⇔ f (g (hx)) -- (.)   (f . g) x ⇔ f (gx) (f . g . h) x ⇔ f (g (hx)) 

---

01_basic / 20_Essential_Haskell / 10a_Functions.lhs

कार्यों को लिखने के लिए उपयोगी चीजें

थोड़ा अनुस्मारक:

 x :: Int ⇔ x   Int x :: a ⇔ x     x :: Num a => a ⇔ x     a,     Num f :: a -> b ⇔ f      a     b f :: a -> b -> c ⇔ f  ,    a   (b→c) f :: (a -> b) -> c ⇔ f  ,    (a→b)   c 

परिभाषित करने से पहले एक फ़ंक्शन प्रकार की घोषणा करना वैकल्पिक है।
हास्केल खुद सबसे आम प्रकार का अनुमान लगाएगा।
लेकिन फ़ंक्शन के प्रकार को निर्दिष्ट करना अंगूठे का एक नियम है।

Infix प्रविष्टि

 square :: Num a => a -> a square x = x^2 

ध्यान दें कि ^ उपयोग इन्फिक्स नोटेशन में किया जाता है।
प्रत्येक इन्फिक्स ऑपरेटर के लिए, उपसर्ग लेखन की संभावना है।
बस इच्छित ऑपरेटर को कोष्ठक में संलग्न करें।

 square' x = (^) x 2 square'' x = (^2) x 

हम x को अभिव्यक्ति के बाईं और दाईं ओर से हटा सकते हैं!
इसे η-कमी कहा जाता है।

 square''' = (^2) 

ध्यान दें कि हम ' फ़ंक्शन नाम में वर्ण का उपयोग कर सकते हैं।
उदाहरण के लिए:

square ⇔ square' square'' square '''

परीक्षण

 absolute :: (Ord a, Num a) => a -> a absolute x = if x >= 0 then x else -x 

नोट: if .. then .. else हास्केल में एक if .. then .. else एक ऑपरेटर की तरह अधिक है
¤?¤:¤ सी में। आप else नहीं छोड़ सकते।

एक और समारोह समकक्ष:

 absolute' x | x >= 0 = x | otherwise = -x 

नोट: हास्केल कार्यक्रमों में संरेखण महत्वपूर्ण है।
अजगर के रूप में, मिसलिग्न्मेंट कोड तोड़ सकता है!

कठिन हिस्सा

हम जटिल भाग के अध्ययन के लिए आगे बढ़ते हैं।

क्रियात्मक शैली

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


यहाँ समस्या की स्थिति है जिसे हम हल करेंगे:

पूर्णांकों की सूची होने के कारण, आपको सूची में सम संख्याओं की गणना करना होगा।

उदाहरण:
[1,2,3,4,5] ⇒ 2 + 4 ⇒ 6

कार्यात्मक और अनिवार्य दृष्टिकोण के बीच अंतर दिखाने के लिए, हम सबसे पहले एक अनिवार्य समाधान लिखते हैं (जावास्क्रिप्ट में):

 function evenSum(list) { var result = 0; for (var i=0; i< list.length ; i++) { if (list[i] % 2 ==0) { result += list[i]; } } return result; } 

लेकिन हास्केल में कोई चर और छोर नहीं हैं।
छोरों का उपयोग किए बिना, पुनरावृत्ति का उपयोग करके समान परिणाम प्राप्त किया जा सकता है।

नोट :
अनिवार्य भाषाओं में पुनरावृत्ति एक धीमी उपकरण होने के लिए एक प्रतिष्ठा है। लेकिन अधिकांश कार्यात्मक भाषाओं के लिए ऐसा नहीं है। ज्यादातर मामलों में, हास्केल बहुत उच्च गुणवत्ता में पुनरावर्ती कार्यों के साथ काम का अनुकूलन करता है।

यहाँ C में लिखा गया एक पुनरावर्ती कार्य का एक संस्करण है C सरल के लिए, मैं मानता हूं कि संख्याओं की सूची एक शून्य मान के साथ समाप्त होती है।

 int evenSum(int *list) { return accumSum(0,list); } int accumSum(int n, int *list) { int x; int *xs; if (*list == 0) { // if the list is empty return n; } else { x = list[0]; // let x be the first element of the list xs = list+1; // let xs be the list without x if ( 0 == (x%2) ) { // if x is even return accumSum(n+x, xs); } else { return accumSum(n, xs); } } } 

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

 even :: Integral a => a -> Bool head :: [a] -> a tail :: [a] -> [a] 

समता जाँच।

 even :: Integral a => a -> Bool even 3 ⇒ False even 2 ⇒ True 

head ने सूची का पहला तत्व लौटाया:

 head :: [a] -> a head [1,2,3] ⇒ 1 head [] ⇒ ERROR 

tail सूची के सभी तत्वों को पहले के अलावा लौटाती है:

 tail :: [a] -> [a] tail [1,2,3] ⇒ [2,3] tail [3] ⇒ [] tail [] ⇒ ERROR 

ध्यान दें कि किसी भी गैर-रिक्त सूची l ,
l ⇔ (head l):(tail l)

---

02_हार्ड_पार्ट / 11_Functions.lhs

तो, हास्केल में समस्या का पहला समाधान।
evenSum फ़ंक्शन सूची में सभी सम संख्याओं का योग लौटाता है:

 --  1 evenSum :: [Integer] -> Integer evenSum l = accumSum 0 l accumSum nl = if l == [] then n else let x = head l xs = tail l in if even x then accumSum (n+x) xs else accumSum n xs 

फ़ंक्शन का परीक्षण करने के लिए, बस ghci चलाएं:

 % ghci GHCi, version 7.0.3: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Prelude> :load 11_Functions.lhs [1 of 1] Compiling Main ( 11_Functions.lhs, interpreted ) Ok, modules loaded: Main. *Main> evenSum [1..5] 6 

निम्नलिखित इस बात का एक उदाहरण है कि फ़ंक्शन कैसे काम करता है (मैं धोखा दे रहा हूं। पता है। हम बाद में ढीले कंप्यूटिंग के सवाल पर वापस आएंगे):

 *Main> evenSum [1..5] accumSum 0 [1,2,3,4,5] 1 is odd accumSum 0 [2,3,4,5] 2 is even accumSum (0+2) [3,4,5] 3 is odd accumSum (0+2) [4,5] 4 is even accumSum (0+2+4) [5] 5 is odd accumSum (0+2+4) [] l == [] 0+2+4 0+6 6 

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

 evenSum :: Integral a => [a] -> a 

02_हार्ड_पार्ट / 11_Functions.lhs

---

02_हार्ड_पार्ट / 12_Functions.lhs

अगला कदम यह हो सकता है कि नेस्टेड फ़ंक्शंस का उपयोग where या let साथ परिभाषित किया जाए।
इसलिए, हमारा accumSum कार्य वैश्विक नामस्थान को प्रदूषित नहीं accumSum ।

 --  2 evenSum :: Integral a => [a] -> a evenSum l = accumSum 0 l where accumSum nl = if l == [] then n else let x = head l xs = tail l in if even x then accumSum (n+x) xs else accumSum n xs 

02_हार्ड_पार्ट / 12_Functions.lhs

---

02_हार्ड_पार्ट / 13_Functions.lhs

अब पैटर्न मिलान का उपयोग करें।

 --  3 evenSum l = accumSum 0 l where accumSum n [] = n accumSum n (x:xs) = if even x then accumSum (n+x) xs else accumSum n xs 

पैटर्न मिलान क्या है? यह केवल नामित मापदंडों के बजाय मूल्यों का उपयोग कर रहा है। (सबसे साहसी के लिए, पैटर्न मिलान का एक विस्तृत विवरण यहां अध्ययन किया जा सकता है )

इस कोड के बजाय: foo l = if l == [] then <x> else <y>
आप बस लिख सकते हैं:

 foo [] = <x> foo l = <y> 

लेकिन नमूने के साथ तुलना बहुत कुछ कर सकती है। यह एक जटिल संरचना के आंतरिक डेटा का विश्लेषण कर सकता है। हम बदल सकते हैं

 foo l = let x = head l xs = tail l in if even x then foo (n+x) xs else foo n xs 

पर

 foo (x:xs) = if even x then foo (n+x) xs else foo n xs 

एक बहुत ही उपयोगी सुविधा।
यह हमारे कोड को अधिक संक्षिप्त और पठनीय बनाता है।

02_हार्ड_पार्ट / 13_Functions.lhs

---

02_हार्ड_पार्ट / 14_Functions.lhs

आप ell-कटौती का उपयोग करके हास्केल में लेखन कार्यों को सरल बना सकते हैं।
उदाहरण के लिए, ऐसी प्रविष्टि के बजाय:

 fx = (- ) x 

उपयोग कर सकते हैं

 f = -  

हम इस दृष्टिकोण का उपयोग l छुटकारा पाने के लिए कर सकते हैं:

 --  4 evenSum :: Integral a => [a] -> a evenSum = accumSum 0 where accumSum n [] = n accumSum n (x:xs) = if even x then accumSum (n+x) xs else accumSum n xs 

02_हार्ड_पार्ट / 14_Functions.lhs

---

02_हार्ड_पार्ट / 15_Functions.lhs

उच्च आदेश कार्य

हमारे कार्य को और अधिक सुंदर बनाने के लिए, हम FEP (उच्च क्रम के कार्यों) का उपयोग कर सकते हैं।
आप पूछते हैं कि किस तरह के जानवर हैं?
उच्च-क्रम फ़ंक्शन ऐसे कार्य हैं जो पैरामीटर के रूप में कार्य करते हैं।

कुछ उदाहरण:

 filter :: (a -> Bool) -> [a] -> [a] map :: (a -> b) -> [a] -> [b] foldl :: (a -> b -> a) -> a -> [b] -> a 

हम छोटे कदमों में आगे बढ़ेंगे।

 --  5 evenSum l = mysum 0 (filter even l) where mysum n [] = n mysum n (x:xs) = mysum (n+x) xs 

जहाँ

 filter even [1..10] ⇔ [2,4,6,8,10] 

filter फ़ंक्शन तर्कों को फ़ंक्शन के प्रकार ( a -> Bool ) और प्रकार की सूची [a] रूप में लेता है। यह केवल उन तत्वों से युक्त एक सूची देता है, जिसके लिए फ़ंक्शन true लौटा।

हमारा अगला कदम चक्र को और सरल बनाना होगा। हम foldl फ़ंक्शन का उपयोग करते हैं, जो हमें एक मूल्य जमा करने की अनुमति देता है। foldl समारोह एक लोकप्रिय प्रोग्रामिंग तकनीक को लागू करता है:

 myfunc list = foo initialValue list foo accumulated [] = accumulated foo tmpValue (x:xs) = foo (bar tmpValue x) xs 

उपरोक्त कोड को निम्न द्वारा प्रतिस्थापित किया जा सकता है:

 myfunc list = foldl bar initialValue list 

यदि आप वास्तव में समझना चाहते हैं कि जादू क्या हो रहा है,
foldl कार्यान्वयन नीचे दिया गया है।

 foldl fz [] = z foldl fz (x:xs) = foldl f (fzx) xs 

 foldl fz [x1,...xn] ⇔ f (... (f (fz x1) x2) ...) xn 

लेकिन चूंकि हास्केल एक आलसी भाषा है, इसलिए यह मान (fzx) गणना नहीं करता है, लेकिन इसे स्टैक (fzx) धकेल देता है।
इसलिए, हम foldl' जगह foldl' उपयोग करेंगे;
foldl' का एक सख्त (या ऊर्जावान) कार्यान्वयन है।

यदि आलसी और सख्त कार्यों के बीच अंतर आपके लिए स्पष्ट नहीं है, तो चिंता न करें, बस कोड को पढ़ें, यह देखते हुए कि दोनों फ़ंक्शन समान हैं।


अब evenSum का हमारा संस्करण इस तरह दिखता है:

 --  6 -- foldl'     --       Data.List import Data.List evenSum l = foldl' mysum 0 (filter even l) where mysum acc value = acc + value 

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

 --  7 --     --     import Data.List (foldl') evenSum l = foldl' (\xy -> x+y) 0 (filter even l) 

और निश्चित रूप से, हम निम्नलिखित प्रतिस्थापन कर सकते हैं

 (\xy -> x+y) ⇔ (+) 

02_हार्ड_पार्ट / 15_Functions.lhs

---

02_हार्ड_पार्ट / 16_Functions.lhs

अंत में

 --  8 import Data.List (foldl') evenSum :: Integral a => [a] -> a evenSum l = foldl' (+) 0 (filter even l) 

foldl'सबसे सहज सुविधा नहीं। लेकिन यह निश्चित रूप से निपटने के लायक है।

ऐसा करने के लिए, हम एक कदम-दर-चरण विश्लेषण करते हैं:

 evenSum [1,2,3,4] ⇒ foldl' (+) 0 (filter even [1,2,3,4]) ⇒ foldl' (+) 0 [2,4] ⇒ foldl' (+) (0+2) [4] ⇒ foldl' (+) 2 [4] ⇒ foldl' (+) (2+4) [] ⇒ foldl' (+) 6 [] ⇒ 6 

एक अन्य उपयोगी उच्च क्रम फ़ंक्शन यह है (.)।
फ़ंक्शन (.)गणितीय संरचना से मेल खाती है।

 (f . g . h) x ⇔ f ( g (hx)) 

हम इसका उपयोग अपने कार्य को और कम करने के लिए कर सकते हैं:

 --  9 import Data.List (foldl') evenSum :: Integral a => [a] -> a evenSum = (foldl' (+) 0) . (filter even) 

कोड क्लीनर बनाने के लिए आप कुछ और कर सकते हैं:

 --  10 import Data.List (foldl') sum' :: (Num a) => [a] -> a sum' = foldl' (+) 0 evenSum :: Integral a => [a] -> a evenSum = sum' . (filter even) 

हम परिणाम पर चर्चा करते हैं।
उच्च आदेश कार्यों को लागू करने से हमें क्या मिला?

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

 [1,2,3,4] ▷ [1,4,9,16] ▷ [4,16] ▷ 20 

संस्करण 10 में यह परिवर्तन जोड़ना बहुत सरल है:

 squareEvenSum = sum' . (filter even) . (map (^2)) squareEvenSum' = evenSum . (map (^2)) squareEvenSum'' = sum' . (map (^2)) . (filter even) 

हमें केवल एक और "ट्रांसफ़ॉर्म फ़ंक्शन" जोड़ने की आवश्यकता है (ध्यान दें कि यह squareEvenSum''अन्य दो कार्यान्वयन की तुलना में अधिक कुशल है। ऑर्डर (.)वास्तव में मायने रखता है।)

 map (^2) [1,2,3,4] ⇔ [1,4,9,16] 

फ़ंक्शन mapकेवल सूची के सभी तत्वों के लिए पैरामीटर फ़ंक्शन लागू करता है।

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

हम पाठक के लिए एक कार्य के रूप में एक संस्करण को फिर से पढ़ना छोड़ देंगे।

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

हमारे उदाहरण में, हम देख सकते हैं कि कैसे शक्तिशाली कार्यात्मक प्रोग्रामिंग हो सकती है। दुर्भाग्य से, कुछ मामलों में, विशुद्ध रूप से कार्यात्मक भाषाएँ हमेशा सबसे अच्छा विकल्प नहीं होती हैं। बहुत कम से कम, वास्तव में सार्वभौमिक कार्यात्मक भाषा अभी तक नहीं बनाई गई है।

हास्केल की विशिष्ट विशेषताओं में से एक डीएसएलएस (डोमेन-ओरिएंटेड लैंग्वेज) के निर्माण में निहित है।


वास्तव में, हास्केल एक महान उपकरण है, भले ही आप अनिवार्य शैली में कार्यक्रम लिखना चाहते हैं। जब मैंने हास्केल का अध्ययन किया, तो यह विचार मेरे लिए एक रहस्योद्घाटन था।


लेकिन इससे पहले कि हम हास्केल की महाशक्ति के बारे में बात करना कम कर दें, हमें एक और महत्वपूर्ण पहलू - प्रकारों पर चर्चा करने की आवश्यकता है ।

प्रकार

tl; डॉआर :

• type Name = AnotherTypeयह बस संकलक प्रकार के लिए एक उपनाम है Nameऔर AnotherTypeएक ही लग रही है।
• data Name = NameConstructor AnotherType और इस उदाहरण में, प्रकार भिन्न हैं।
• data पुनरावर्ती संरचनाएँ बना सकते हैं।
• deriving यह एक शक्तिशाली जादू टोना है और आपके लिए कार्य बना सकता है।

हास्केल एक ऐसी भाषा है जिसमें मजबूत स्टेटिक टाइपिंग है।

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

प्रकार का अनुमान

फास्ट प्रोग्राम बनाने के लिए स्टैटिक टाइपिंग आवश्यक है।
लेकिन ज्यादातर वैधानिक रूप से टाइप की जाने वाली भाषाएं अवधारणाओं को सामान्य बनाने में कमजोर होती हैं।

हास्केल की गंभीर क्षमताओं में से एक प्रकार का अनुमान है ।

एक साधारण उदाहरण।
समारोह squareभाषा हास्केल में:

 square x = x * x 

यह फ़ंक्शन squareकिसी भी प्रकार के न्यूमरल को (वर्ग) कर सकता है ।
आप एक मान प्रकार के लिए पारित कर सकते हैं Int, Integer, Float, Fractionalऔर यहां तक कि Complex। उदाहरण के लिए:

 % ghci GHCi, version 7.0.4: ... Prelude> let square x = x*x Prelude> square 2 4 Prelude> square 2.1 4.41 Prelude> --   Data.Complex Prelude> :m Data.Complex Prelude Data.Complex> square (2 :+ 1) 3.0 :+ 4.0 

x :+ yयह एक जटिल संख्या ( x + iy ) का अंकन है ।

अब C प्रोग्राम की तुलना में कोड की मात्रा की तुलना करें:

 int int_square(int x) { return x*x; } float float_square(float x) {return x*x; } complex complex_square (complex z) { complex tmp; tmp.real = z.real * z.real - z.img * z.img; tmp.img = 2 * z.img * z.real; } complex x,y; y = complex_square(x); 

प्रत्येक प्रकार के लिए आपको अपना स्वयं का फ़ंक्शन लिखना होगा। आप केवल मेटाप्रोग्रामिंग तकनीकों का उपयोग करके इसे प्राप्त कर सकते हैं। उदाहरण के लिए प्रीप्रोसेसर का उपयोग करना। C ++ टेम्पलेट का उपयोग करके अधिक सुंदर समाधान प्रदान करता है:

 #include <iostream> #include <complex> using namespace std; template<typename T> T square(T x) { return x*x; } int main() { // int int sqr_of_five = square(5); cout << sqr_of_five << endl; // double cout << (double)square(5.3) << endl; // complex cout << square( complex<double>(5,3) ) << endl; return 0; } 

सी ++ संस्करण सी की तुलना में बहुत बेहतर दिखता है।
लेकिन एक जटिल चर के कार्यों के लिए, एक ही वाक्यविन्यास को बनाए रखना मुश्किल होगा। एक उदाहरण इस लेख में पाया जा सकता है
।
।

C ++ में, आपको एक फ़ंक्शन का वर्णन करना होगा जो विभिन्न प्रकारों के साथ काम कर सकता है।
हास्केल में, स्थिति विपरीत है।
फ़ंक्शन डिफ़ॉल्ट रूप से यथासंभव सामान्यीकृत किया जाएगा।

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

"अगर यह संकलित करता है, तो यह सबसे सही तरीके से काम करता है"

---

02_हार्ड_पार्ट / 21_Types.lhs

नए प्रकार बनाना

आप अपने खुद के प्रकार बना सकते हैं। उदाहरण के लिए, आप टाइप पर्यायवाची घोषित कर सकते हैं।

 type Name = String type Color = String showInfos :: Name -> Color -> String showInfos name color = "Name: " ++ name ++ ", Color: " ++ color name :: Name name = "Robin" color :: Color color = "Blue" main = putStrLn $ showInfos name color 

लेकिन यह आपको गलतियों से बहुत ज्यादा नहीं बचाता है।
फ़ंक्शन के दो मापदंडों को बदलने showInfosऔर प्रोग्राम चलाने के लिए प्रयास करें :

 putStrLn $ showInfos color name 

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

 data Name = NameConstr String data Color = ColorConstr String showInfos :: Name -> Color -> String showInfos (NameConstr name) (ColorConstr color) = "Name: " ++ name ++ ", Color: " ++ color name = NameConstr "Robin" color = ColorConstr "Blue" main = putStrLn $ showInfos name color 

यदि आप showInfosपैरामीटर स्वैप करते हैं, तो कंपाइलर शपथ लेना शुरू कर देगा। गलतियाँ करने का मौका गायब हो गया है। लेकिन कोड की मात्रा बढ़ाने की कीमत पर।

ध्यान दें कि प्रकार के निर्माता कार्य हैं:

 NameConstr :: String -> Name ColorConstr :: String -> Color 

उपयोग dataआमतौर पर इस तरह दिखता है:

 data TypeName = ConstructorName [types] | ConstructorName2 [types] | ... 

के लिए
DataTypeName और DataTypeConstructor आमतौर पर एक ही नाम का उपयोग करें।
उदाहरण के लिए:

 data Complex = Num a => Complex aa 

आप प्रविष्टियों का सिंटैक्स भी उपयोग कर सकते हैं:

 data DataTypeName = DataConstructor { field1 :: [type of field1] , field2 :: [type of field2] ... , fieldn :: [type of fieldn] } 

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

एक उदाहरण:

 data Complex = Num a => Complex { real :: a, img :: a} c = Complex 1.0 2.0 z = Complex { real = 3, img = 4 } real c ⇒ 1.0 img z ⇒ 4 

02_हार्ड_पार्ट / 22_Types.lhs

---

02_हार्ड_पार्ट / 23_Types.lhs

पुनरावर्ती प्रकार

आप पहले से ही पुनरावर्ती प्रकारों के प्रतिनिधि से मिल चुके हैं - सूचियों के साथ। आप एक अधिक क्रिया सिंटैक्स का उपयोग करके स्क्रैच से सूची बना सकते हैं:

 data List a = Empty | Cons a (List a) 

एक आसान रिकॉर्ड के लिए, आप एक infix प्रकार कंस्ट्रक्टर का उपयोग कर सकते हैं।

 infixr 5 ::: data List a = Nil | a ::: (List a) 

इसके बाद infixrका नंबर ऑपरेटर की प्राथमिकता है।

यदि आप प्रिंट करना चाहते हैं ( Show), पढ़ें ( Read), समानता की जांच करें ( Eq) और Ordअपने नए प्रकार के मूल्यों की तुलना करें ( ), आप हास्केल को इसके लिए आवश्यक कार्यों को स्वचालित रूप से प्रिंट करने के लिए कह सकते हैं।

 infixr 5 ::: data List a = Nil | a ::: (List a) deriving (Show,Read,Eq,Ord) 

जब आप deriving (Show)अपने प्रकार के विवरण में जोड़ते हैं , तो हास्केल स्वचालित रूप से आपके लिए एक फ़ंक्शन बनाता है show। जल्द ही हम देखेंगे कि आप फ़ंक्शन के अपने संस्करण को कैसे लिख सकते हैं show।

 convertList [] = Nil convertList (x:xs) = x ::: convertList xs 

 main = do print (0 ::: 1 ::: Nil) print (convertList [0,1]) 

कार्यक्रम का आउटपुट:

 0 ::: (1 ::: Nil) 0 ::: (1 ::: Nil) 

02_हार्ड_पार्ट / 23_Types.lhs

---

02_हार्ड_पार्ट / 30_Trees.lhs

पेड़

यहां एक और मानक उदाहरण है: द्विआधारी पेड़।

 import Data.List data BinTree a = Empty | Node a (BinTree a) (BinTree a) deriving (Show) 

आइए एक फ़ंक्शन लिखें जो एक सूची को एक ऑर्डर किए गए बाइनरी ट्री में परिवर्तित करता है।

 treeFromList :: (Ord a) => [a] -> BinTree a treeFromList [] = Empty treeFromList (x:xs) = Node x (treeFromList (filter (<x) xs)) (treeFromList (filter (>x) xs)) 

इस सुविधा का आनंद लें।
रूसी में अनुवाद:

• एक खाली सूची एक खाली पेड़ में बदल जाती है।
• सूची में (x:xs)एक पेड़ बन जाएगा जिसमें:
  
  • जड़ होगा x
  • बाईं सबट्री सूची में बनाया जाएगा, xsसख्ती से छोटा होता है xऔर
  • सही उप-सूची सूची तत्वों xsसे कड़ाई से बड़ी बनाई जाएगी x।
  
  

 main = print $ treeFromList [7,2,4,8] 

आपको कुछ इस तरह मिलना चाहिए:

 Node 7 (Node 2 Empty (Node 4 Empty Empty)) (Node 8 Empty Empty) 

यह एक सूचनात्मक है, लेकिन हमारे पेड़ का बहुत सुंदर प्रतिनिधित्व नहीं है।

02_हार्ड_पार्ट / 30_Trees.lhs

---

02_Hard_Part / 31_Trees.lhs

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

हमें छोटे बदलाव करने की जरूरत है।
हम deriving (Show)प्रकार की घोषणा से हटा देंगे BinTree। यह बिनट्री को प्रकार की कक्षाओं ( Eqऔर Ord) का एक उदाहरण बनाने के लिए भी उपयोगी होगा । यह हमें समानता के लिए पेड़ों का परीक्षण करने और उनकी तुलना करने का अवसर देगा।

 data BinTree a = Empty | Node a (BinTree a) (BinTree a) deriving (Eq,Ord) 

बिना deriving (Show), हास्केल हमारे लिए एक विधि नहीं बनाएगा show।
लेकिन हम अपना खुद का संस्करण लिखेंगे show। ऐसा करने के लिए, हमें यह संकेत देना चाहिए कि हमारा नया बनाया BinTree a
गया प्रकार, वर्ग का एक उदाहरण है Show।
कोड में, यह इस तरह दिखता है:

 instance Show (BinTree a) where show t = ... --      

यहाँ एक बाइनरी ट्री प्रदर्शित करने का मेरा संस्करण है। यह उतना डरावना नहीं है जितना दिखता है। मैंने इसे बहुत अधिक अजीब वस्तुओं को प्रदर्शित करने के लिए अनुकूलित किया।

 --   BinTree   Show instance (Show a) => Show (BinTree a) where --     '<' --   :    show t = "< " ++ replace '\n' "\n: " (treeshow "" t) where -- treeshow pref Tree --        pref --       treeshow pref Empty = "" -- Leaf treeshow pref (Node x Empty Empty) = (pshow pref x) --    treeshow pref (Node x left Empty) = (pshow pref x) ++ "\n" ++ (showSon pref "`--" " " left) --    treeshow pref (Node x Empty right) = (pshow pref x) ++ "\n" ++ (showSon pref "`--" " " right) --        treeshow pref (Node x left right) = (pshow pref x) ++ "\n" ++ (showSon pref "|--" "| " left) ++ "\n" ++ (showSon pref "`--" " " right) --      showSon pref before next t = pref ++ before ++ treeshow (pref ++ next) t -- pshow  "\n"  "\n"++pref pshow pref x = replace '\n' ("\n"++pref) (show x) --    replace c new string = concatMap (change c new) string where change c new x | x == c = new | otherwise = x:[] -- "x" 

तरीका treeFromListनहीं बदलता है।

 treeFromList :: (Ord a) => [a] -> BinTree a treeFromList [] = Empty treeFromList (x:xs) = Node x (treeFromList (filter (<x) xs)) (treeFromList (filter (>x) xs)) 

और अब हम चारों ओर खेल सकते हैं:

 main = do putStrLn "Int binary tree:" print $ treeFromList [7,2,4,8,1,3,6,21,12,23] 

 print $ treeFromList [7,2,4,8,1,3,6,21,12,23] Int binary tree: < 7 : |--2 : | |--1 : | `--4 : | |--3 : | `--6 : `--8 : `--21 : |--12 : `--23 

बहुत बेहतर! पेड़ की जड़ को एक प्रतीक के साथ प्रदर्शित किया गया है <। और प्रत्येक बाद की पंक्ति के साथ शुरू होता है :।
लेकिन हम दूसरे प्रकार का उपयोग कर सकते हैं।

 putStrLn "\nString binary tree:" print $ treeFromList ["foo","bar","baz","gor","yog"] 

 String binary tree: < "foo" : |--"bar" : | `--"baz" : `--"gor" : `--"yog" 

और जब से हम समानता के लिए पेड़ों का परीक्षण कर सकते हैं और उनका क्रम निर्धारित कर सकते हैं, हम पेड़ों का एक पेड़ बना सकते हैं!

 putStrLn "\n      :" print ( treeFromList (map treeFromList ["baz","zara","bar"])) 

       : < < 'b' : : |--'a' : : `--'z' : |--< 'b' : | : |--'a' : | : `--'r' : `--< 'z' : : `--'a' : : `--'r' 

इसीलिए मैंने प्रत्येक नई पंक्ति (मूल को छोड़कर) के उपसर्ग के रूप में चुना है :।

 putStrLn "\nTree of Binary trees of Char binary trees:" print $ (treeFromList . map (treeFromList . map treeFromList)) [ ["YO","DAWG"] , ["I","HEARD"] , ["I","HEARD"] , ["YOU","LIKE","TREES"] ] 

जो निम्नलिखित के बराबर है:

 print ( treeFromList ( map treeFromList [ map treeFromList ["YO","DAWG"] , map treeFromList ["I","HEARD"] , map treeFromList ["I","HEARD"] , map treeFromList ["YOU","LIKE","TREES"] ])) 

और परिणामस्वरूप:

 Binary tree of Binary trees of Char binary trees: < < < 'Y' : : : `--'O' : : `--< 'D' : : : |--'A' : : : `--'W' : : : `--'G' : |--< < 'I' : | : `--< 'H' : | : : |--'E' : | : : | `--'A' : | : : | `--'D' : | : : `--'R' : `--< < 'Y' : : : `--'O' : : : `--'U' : : `--< 'L' : : : `--'I' : : : |--'E' : : : `--'K' : : `--< 'T' : : : `--'R' : : : |--'E' : : : `--'S' 

कृपया ध्यान दें कि डुप्लिकेट सम्मिलित नहीं हैं।
केवल एक ही पेड़ प्रदर्शित होता है "I","HEARD"। हमें यह सुविधा (लगभग) मुफ्त में मिली है, क्योंकि हमने ट्री को एक उदाहरण घोषित किया है Eq।

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


02_हार्ड_पार्ट / 31_Trees.lhs

---

02_हार्ड_पार्ट / 40_Infinites_Structures.lhs

अंतहीन संरचनाएं

हास्केल को अक्सर एक आलसी भाषा कहा जाता है ।

लेकिन यह कहना सही है कि हास्केल एक सख्त भाषा नहीं है । आलस्य गैर-सख्त भाषाओं का एक लोकप्रिय कार्यान्वयन है।

एक शिथिल भाषा क्या है? हास्केल-विकी से:

कटौती (एक अभिव्यक्ति की गणना के लिए एक गणितीय शब्द) बाहर से अंदर तक जाती है।

यदि आपके पास एक अभिव्यक्ति है (a+(b*c)), तो आप पहले मूल्यांकन करते हैं +, और फिर आंतरिक अभिव्यक्ति(b*c)

उदाहरण के लिए, हास्केल का उपयोग करके, आप यह कर सकते हैं:

 -- numbers = [1,2,..] numbers :: [Integer] numbers = 0:map (1+) numbers take' n [] = [] take' 0 l = [] take' n (x:xs) = x:take' (n-1) xs main = print $ take' 10 numbers 

और कार्यक्रम समाप्त होता है।

कैसे?

सब कुछ गणना करने के बजाय , यह केवल आवश्यक तत्वों की गणना करता है।

हास्केल में अंतहीन सूचियों को निर्दिष्ट करने के लिए सिंटैक्स पर ध्यान दें

 [1..] ⇔ [1,2,3,4...] [1,3..] ⇔ [1,3,5,7,9,11...] 

और अधिकांश फ़ंक्शन ऐसी सूचियों के साथ काम करने में सक्षम होंगे। यहां तक ​​कि takeहमारे लिए समान मानक सुविधा भी है take'।

02_हार्ड_पार्ट / 40_Infinites_Structures.lhs

---

02_Hard_Part / 41_Infinites_Structures.lhs

मान लें कि हमें ऑर्डर किए गए बाइनरी ट्री से कोई आपत्ति नहीं है। यहाँ एक अनंत बाइनरी ट्री का उदाहरण दिया गया है:

 nullTree = Node 0 nullTree nullTree 

प्रत्येक नोड पर शून्य के साथ एक पूर्ण बाइनरी ट्री। अब मैं आपको यह साबित करूंगा कि हम इस पेड़ के साथ निम्नलिखित कार्य कर सकते हैं:

 --    BinTree --      treeTakeDepth _ Empty = Empty treeTakeDepth 0 _ = Empty treeTakeDepth n (Node x left right) = let nl = treeTakeDepth (n-1) left nr = treeTakeDepth (n-1) right in Node x nl nr 

आइए देखें कि यह कार्यक्रम क्या उत्पादन करेगा:

 main = print $ treeTakeDepth 4 nullTree 

यह कोड निम्नलिखित परिणाम को संकलित करता है, शुरू करता है, रोकता है और प्रदर्शित करता है:

 < 0 : |-- 0 : | |-- 0 : | | |-- 0 : | | `-- 0 : | `-- 0 : | |-- 0 : | `-- 0 : `-- 0 : |-- 0 : | |-- 0 : | `-- 0 : `-- 0 : |-- 0 : `-- 0 

न्यूरॉन्स को थोड़ा हिलाने के लिए, पेड़ को अजीब बनायें:

 iTree = Node 0 (dec iTree) (inc iTree) where dec (Node xlr) = Node (x-1) (dec l) (dec r) inc (Node xlr) = Node (x+1) (inc l) (inc r) 

उच्च आदेश कार्यों का उपयोग करके एक समान पेड़ भी बनाया जा सकता है।
यह फ़ंक्शन समान है map, लेकिन BinTreeसूची के बजाय इसके साथ काम करना चाहिए ।
इस तरह के एक समारोह का एक संभावित कार्यान्वयन यहां दिया गया है:

 --      Tree treeMap :: (a -> b) -> BinTree a -> BinTree b treeMap f Empty = Empty treeMap f (Node x left right) = Node (fx) (treeMap f left) (treeMap f right) 

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

हमारा कार्यान्वयन:

 infTreeTwo :: BinTree Int infTreeTwo = Node 0 (treeMap (\x -> x-1) infTreeTwo) (treeMap (\x -> x+1) infTreeTwo) 

और अमल का नतीजा

 main = print $ treeTakeDepth 4 infTreeTwo 

 < 0 : |-- -1 : | |-- -2 : | | |-- -3 : | | `-- -1 : | `-- 0 : | |-- -1 : | `-- 1 : `-- 1 : |-- 0 : | |-- -1 : | `-- 1 : `-- 2 : |-- 1 : `-- 3 

02_Hard_Part / 41_Infinites_Structures.lhs