कांटों के माध्यम से हास्केल (अनुवाद)। 2/2

अनुवाद का दूसरा भाग हास्केल का संक्षिप्त और कठिन परिचय है। पहले वाला यहाँ उपलब्ध है।

यहां मूल

• धिक्कार है कठिन हिस्सा
  
  • आईओ से निपटना
  • IO चाल स्पष्टीकरण
  • इकाई
    
    • शायद यह एक सन्यासी है
    • सनद रहे
    
    
  
  
• आवेदन
  
  • अंतहीन पेड़ के बारे में कुछ शब्द
  
  

धिक्कार है कठिन हिस्सा

बधाई! तुम सच में बहुत दूर हो गए।
और अब कचरा, अपशिष्ट और सोडोमी शुरू हो जाएगा :)।

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

• दुष्प्रभाव के साथ क्या करना है?
• इनपुट-आउटपुट (IO) के साथ काम करने के लिए आपको इस तरह के अजीब सिंटैक्स की आवश्यकता क्यों थी?

तैयार हो जाओ, जवाब सबसे सरल नहीं हो सकते हैं।
लेकिन उनके लाभ निर्विवाद होंगे।

---

03_हेल / 01_IO / 01_progressive_io_example.lhs

आईओ से निपटना

tl; डॉआर :

एक विशिष्ट कार्य जो IO साथ काम करता है, लगभग एक अनिवार्य कार्यक्रम जैसा दिखता है:

 f :: IO a f = do x <- action1 action2 x y <- action3 action4 xy 

• किसी ऑब्जेक्ट का मान असाइन करने के लिए, हम <- उपयोग करते हैं।
• इस उदाहरण में, प्रत्येक पंक्ति में अभिव्यक्ति का प्रकार IO * ;
  
  • action1 :: IO b
  • action2 x :: IO ()
  • action3 :: IO c
  • action4 xy :: IO a
  • x :: b , y :: c
  
  
• कई ऑब्जेक्ट प्रकार IO a ।
  ऐसी वस्तुओं के साथ आप शुद्ध कार्यों का उपयोग नहीं कर सकते।
  शुद्ध कार्यों का उपयोग करने के लिए आपको action2 (purefunction x) ।

इस खंड में मैं दिखाऊंगा कि IO का उपयोग कैसे किया जाता है, लेकिन यह नहीं कि यह कैसे काम करता है।
आप देखेंगे कि हास्केल कार्यक्रम के स्वच्छ भागों को साइड इफेक्ट्स से अलग कैसे करता है।

यदि वाक्य-विन्यास का कोई विवरण थोड़ा सा समझ में नहीं आता है, तो रोकें नहीं।
हम अगले भाग में उनके पास लौटेंगे।

हम क्या पाना चाहते हैं?

उपयोगकर्ता से संख्याओं की एक सूची प्राप्त करें। उनकी राशि प्रिंट करें

 toList :: String -> [Integer] toList input = read ("[" ++ input ++ "]") main = do putStrLn "   ( ):" input <- getLine print $ sum (toList input) 

इस कार्यक्रम का व्यवहार स्पष्ट होना चाहिए।
लेकिन चलो प्रकारों पर करीब से नज़र डालें।

 putStrLn :: String -> IO () getLine :: IO String print :: Show a => a -> IO () 

क्या आपने देखा है कि do block में प्रत्येक अभिव्यक्ति IO a प्रकार की IO a ?

 main = do putStrLn " ... " :: IO () getLine :: IO String print Something :: IO () 

<- चरित्र के व्यवहार पर भी ध्यान दें।

 do x <- something 

अगर something :: IO a , तो x :: a ।

IO का उपयोग करने पर महत्वपूर्ण ध्यान दें। दो-ब्लॉक में सभी पंक्तियों को दो तरीकों में से एक में देखना चाहिए:

 action1 :: IO a --      a = () 

या

 value <- action2 --  -- bar zt :: IO b -- value :: b 

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

03_हेल / 01_IO / 01_progressive_io_example.lhs

---

03_हेल / 01_IO / 02_progressive_io_example.lhs

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

  % runghc 02_progressive_io_example.lhs Enter a list of numbers (separated by comma): foo Prelude.read: no parse 

Arrrgghhhh! शैतानी त्रुटि संदेश और कार्यक्रम दुर्घटना!
फिर हमें पहला कदम बनाने की आवश्यकता है ताकि त्रुटि संदेश पढ़ने में आसान हो।

ऐसा करने के लिए, हमें यह समझना चाहिए कि कुछ गलत हुआ।
एक तरीका Maybe प्रकार का उपयोग करना है।
इस प्रकार का उपयोग अक्सर हास्केल कार्यक्रमों में किया जाता है।

 import Data.Maybe 

यह क्या चीज है? Maybe यह एक प्रकार है जो एक पैरामीटर लेता है। यहाँ उसकी परिभाषा है:

 data Maybe a = Nothing | Just a 

यह समझने का एक अच्छा तरीका है कि क्या कोई मान बनाने या बनाने की कोशिश करते समय कोई त्रुटि हुई है।
maybeRead ' maybeRead फ़ंक्शन इस दृष्टिकोण का एक बड़ा उदाहरण है।
यह फ़ंक्शन read फ़ंक्शन के समान है (जो कि जावास्क्रिप्ट फ़ंक्शन eval समान है, जो JSON स्ट्रिंग, को प्रोसेस करता है।
लेकिन अगर कुछ गलत होता है, तो परिणाम Nothing होगा।
और यदि परिणाम सही है, तो यह Just <> लौटेगा।
इस फीचर में गहराई से उतरने की कोशिश न करें।
इसमें कोड read तुलना में कम है; ।

 maybeRead :: Read a => String -> Maybe a maybeRead s = case reads s of [(x,"")] -> Just x _ -> Nothing 

अब जब कोड अधिक पठनीय हो गया है, हम एक फ़ंक्शन लिखेंगे जो निम्नलिखित कार्य करता है:
यदि स्ट्रिंग गलत प्रारूप में आया, तो यह Nothing लौटाएगा।
अन्य मामलों में, उदाहरण के लिए, "1,2,3" के लिए, यह Just [1,2,3] वापस आ जाएगी।

 getListFromString :: String -> Maybe [Integer] getListFromString str = maybeRead $ "[" ++ str ++ "]" 

अब मुख्य फ़ंक्शन का उपयोग करके हमारे कोड का परीक्षण करें।

 main :: IO () main = do putStrLn "  ,  :" input <- getLine let maybeList = getListFromString input in case maybeList of Just l -> print (sum l) Nothing -> error "  . ." 

त्रुटि के मामले में, हम एक अच्छा त्रुटि संदेश दिखाते हैं।

इस मामले में, मुख्य फ़ंक्शन के do-block में प्रत्येक अभिव्यक्ति का प्रकार IO a के रूप में रहता IO a ।
केवल अजीब चीज error ।
error msg फ़ंक्शन किसी भी प्रकार के इनपुट ( IO () हमारे मामले में) को स्वीकार करता है।

एक बहुत महत्वपूर्ण बात पर ध्यान दें - सभी कार्यों के प्रकार पूर्वनिर्धारित हैं।
केवल एक फ़ंक्शन है, प्रकार IO साथ और यह: main ।
इसका मतलब है कि मुख्य एक शुद्ध कार्य नहीं है।
लेकिन यह शुद्ध getListFromString फ़ंक्शन का उपयोग करता है।
केवल घोषित प्रकारों को देखकर, हम दुष्प्रभावों से शुद्ध कार्यों को अलग कर सकते हैं।


शुद्ध कार्य क्यों महत्वपूर्ण हैं?
मैं कुछ चीजें भूल सकता हूं, लेकिन यहां तीन मुख्य कारण हैं:

• साफ कोड पार्स करने के लिए बहुत आसान है।
• सफाई आपको साइड इफेक्ट्स से जुड़ी जटिल प्रजनन योग्य त्रुटियों से बचाती है।
• आप किसी भी क्रम में या बिना किसी जोखिम के समानांतर भी शुद्ध कार्यों की गणना कर सकते हैं।

इन कारणों से, आपको स्वच्छ कार्यों में यथासंभव अधिक कोड रखना चाहिए।

03_हेल / 01_IO / 02_progressive_io_example.lhs

---

03_Hell / 01_IO / 03_progressive_io_example.lhs

अगला कदम उपयोगकर्ता को लगातार सर्वेक्षण करना है जब तक कि वह सही उत्तर नहीं देता।

पहला भाग अपरिवर्तित रहेगा:

 import Data.Maybe maybeRead :: Read a => String -> Maybe a maybeRead s = case reads s of [(x,"")] -> Just x _ -> Nothing getListFromString :: String -> Maybe [Integer] getListFromString str = maybeRead $ "[" ++ str ++ "]" 

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

 askUser :: IO [Integer] askUser = do putStrLn "  ,  :" input <- getLine let maybeList = getListFromString input in case maybeList of Just l -> return l Nothing -> askUser 

इस फ़ंक्शन का प्रकार IO [Integer] ।
इसका मतलब है कि हमें IO क्रियाओं का उपयोग करके [Integer] जैसा परिणाम मिला।
कुछ लोग इसे इस तरह से समझाते हैं:

"यह [Integer] IO अंदर है"

यदि आप I / O तंत्र की आंतरिक संरचना को समझना चाहते हैं, तो अगले भाग को पढ़ें।
लेकिन वास्तव में, यदि आप IO का उपयोग करना चाहते हैं, तो बस कुछ सरल प्रोग्राम लिखें और प्रकारों के बारे में सोचना न भूलें।

परिणामस्वरूप, हमारा मुख्य कार्य बहुत सरल हो गया:

 main :: IO () main = do list <- askUser print $ sum list 

यह IO लिए हमारे परिचय का निष्कर्ष निकालता है। सब कुछ बहुत तेजी से हुआ। यहां कुछ चीजें हैं जो मैं आपको याद रखना चाहता हूं:

• प्रत्येक ब्लॉक में प्रत्येक अभिव्यक्ति प्रकार IO a की होनी चाहिए।
  आपके पास संभावित अभिव्यक्तियों का काफी सीमित सेट है:
  getLine , print , putStrLn , आदि।
• सबसे शुद्ध सुविधाओं का लाभ उठाएं।
• IO a टाइप का अर्थ है निम्नलिखित - IO क्रिया जो टाइप a का परिणाम देता a ।
  कार्यों का प्रतिनिधित्व करने के लिए IO प्रकार, और IO a एक प्रकार का कार्य है।
  यदि आप अभी भी रुचि रखते हैं, तो अगले भाग को पढ़ें।

थोड़ा अभ्यास, और IO का उपयोग करना आपके लिए कोई समस्या नहीं होगी।

व्यायाम :

• एक कार्यक्रम लिखें जो आपके सभी तर्कों को संक्षेप में प्रस्तुत करे। संकेत: getArgs फ़ंक्शन का उपयोग करें।

03_Hell / 01_IO / 03_progressive_io_example.lhs

IO चाल स्पष्टीकरण

tl; डॉआर :

शुद्ध कार्यों में अंतर करने के लिए,
main को एक फ़ंक्शन के रूप main परिभाषित किया गया है जो दुनिया की स्थिति को बदलता है

 main :: World -> World 

इस प्रकार के कार्यों के साइड इफेक्ट होने की गारंटी है। एक विशिष्ट मुख्य कार्य को देखें:

 main w0 = let (v1,w1) = action1 w0 in let (v2,w2) = action2 v1 w1 in let (v3,w3) = action3 v2 w2 in action4 v3 w3 

इस उदाहरण में कई समय मान हैं ( w1 , w2 और w3 )
जिनका उपयोग अगले चरण में डेटा स्थानांतरित करने के लिए किया जाता है।

हम एक bind या (>>=) फ़ंक्शन लिख रहे हैं। bind करने के लिए धन्यवाद bind हमें अब अस्थायी मूल्यों के नाम की आवश्यकता नहीं है।

  main = action1 >>= action2 >>= action3 >>= action4 

बोनस: हास्केल में हमारे लिए सिंटेक्स चीनी है:

  main = do v1 <- action1 v2 <- action2 v1 v3 <- action3 v2 action4 v3 

हमें इस तरह के अजीब सिंटैक्स की आवश्यकता क्यों है, और IO का प्रकार क्या है? जबकि यह सब कुछ जादू सा लगता है।

कुछ समय के लिए, हम शुद्ध कार्यों के बारे में भूल जाते हैं। दुष्प्रभावों पर ध्यान दें:

 askUser :: IO [Integer] askUser = do putStrLn "  ,  :" input <- getLine let maybeList = getListFromString input in case maybeList of Just l -> return l Nothing -> askUser main :: IO () main = do list <- askUser print $ sum list 

सबसे पहले, यह कोड ऐसा दिखता है जैसे यह एक नियमित रूप से अनिवार्य भाषा में लिखा गया था।
साइड-एक्शन कोड को अनिवार्य बनाने के लिए हास्केल काफी ठंडा है।
यदि आप चाहते हैं, तो आप हास्केल पर कुछ while एनालॉग बना सकते हैं।
वास्तविक जीवन में, जब IO साथ काम करते हैं, तो एक अनिवार्य शैली अधिक उपयुक्त होती है।

लेकिन आपने शायद गौर किया कि रिकॉर्डिंग कुछ असामान्य है। तो हमें कारणों का विस्तृत विवरण मिला।

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

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

 main :: World -> World 

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

हास्केल का मानना ​​है कि दुनिया main कार्य के लिए एक इनपुट पैरामीटर है।
लेकिन इस फ़ंक्शन का वास्तविक प्रकार अधिक पसंद है

 main :: World -> ((),World) 

(जो लोग रुचि रखते हैं, उनके लिए अभिव्यक्ति का प्रकार data IO a = IO {unIO :: State# RealWorld -> (# State# RealWorld, a #)} । सभी # ऑप्टिमाइज़ेशन से संबंधित हैं, और उदाहरण में मैंने कई फ़ील्ड निगल लिए हैं। लेकिन कुल मिलाकर, विचार नहीं बदला है।)


प्रकार () एक खाली प्रकार है।
खालीपन।

चलो हमारे समारोह को फिर से लिखना, के बारे में भूल नहीं:

 main w0 = let (list,w1) = askUser w0 in let (x,w2) = print (sum list,w1) in x 

सबसे पहले, साइड इफेक्ट वाले सभी कार्यों में एक निश्चित प्रकार होना चाहिए:

 World -> (a,World) 

जहां a परिणाम का प्रकार है।
उदाहरण के लिए, getChar फ़ंक्शन World -> (Char,World) का प्रकार होना चाहिए World -> (Char,World) ।

एक और गैर-स्पष्ट चीज वह क्रम है जिसमें कार्यों की गणना की जाती है।
हास्केल में, यदि आप fab गणना करने की कोशिश करते हैं, तो आपके पास कई विकल्प होंगे:

• गणना करें तो a b तो fab
• पहले कंप्यूट b , फिर a और अंत में fab ।
• गणना a और समानांतर में b और फिर fab

चूंकि भाषा कार्यात्मक रूप से शुद्ध है, इसलिए इस तरह की चालें वास्तविक हैं।

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

यह ट्रिक शानदार काम करती है।
गणना के प्रत्येक चरण में, कंपाइलर नई बदली हुई दुनिया के लिए एक पॉइंटर पास करेगा।
हुड के तहत, print कुछ इस तरह से काम करता है:

• स्क्रीन पर कुछ प्रिंट करें
• दुनिया आईडी बदलो
• परिणाम के रूप में लौटें ((),__) ।

अब मुख्य सिर्फ भयानक लग रहा है। आइए AskUser फ़ंक्शन के साथ ऐसा ही करें:

 askUser :: World -> ([Integer],World) 

को

 askUser :: IO [Integer] askUser = do putStrLn "  :" input <- getLine let maybeList = getListFromString input in case maybeList of Just l -> return l Nothing -> askUser 

के बाद

 askUser w0 = let (_,w1) = putStrLn "Enter a list of numbers:" in let (input,w2) = getLine w1 in let (l,w3) = case getListFromString input of Just l -> (l,w2) Nothing -> askUser w2 in (l,w3) 

ऐसा लगता है, लेकिन बदसूरत है। बस इन अनाड़ी w* चर को देखो।

हमने जो सबक सीखा है, वह यह है कि कार्यात्मक रूप से शुद्ध भाषा में I / O का अनुभवहीन कार्यान्वयन भयानक लगता है।

सौभाग्य से, इस समस्या को हल करने के लिए अधिक प्रत्यक्ष दृष्टिकोण है। हम पैटर्न देखते हैं। प्रत्येक पंक्ति को इस रूप में दर्शाया गया है:

 let (y,w') = action xw in 

यहां तक ​​कि अगर पहले पैरामीटर x आवश्यकता नहीं है, तो परिणाम एक युगल (answer, newWorldValue) । प्रत्येक फ़ंक्शन f में एक प्रकार होना चाहिए:

 f :: World -> (a,World) 

इसके अलावा, हमने यह भी देखा कि इन कार्यों का उपयोग बहुत समान है:

 let (y,w1) = action1 w0 in let (z,w2) = action2 w1 in let (t,w3) = action3 w2 in ... 

प्रत्येक क्रिया शून्य से n मापदंडों तक हो सकती है। और, विशेष रूप से, प्रत्येक क्रिया इनपुट के रूप में पिछली पंक्ति का परिणाम ले सकती है।

उदाहरण के लिए, हम लिख सकते हैं:

 let (_,w1) = action1 x w0 in let (z,w2) = action2 w1 in let (_,w3) = action3 xz w2 in ... 

और, ज़ाहिर है, actionN w :: (World) -> (a,World) ।

महत्वपूर्ण! केवल दो पैटर्न हैं जिन पर आपको ध्यान देना चाहिए:

 let (x,w1) = action1 w0 in let (y,w2) = action2 x w1 in 

और

 let (_,w1) = action1 w0 in let (y,w2) = action2 w1 in 

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

 bind :: (World -> (a,World)) -> (a -> (World -> (b,World))) -> (World -> (b,World)) 

यह मत भूलो कि (World -> (a,World)) IO कार्रवाई के लिए एक प्रकार है।
आइए सरलता के लिए इसका नाम बदलें:

 type IO a = World -> (a, World) 

कुछ उदाहरण:

 getLine :: IO String print :: Show a => a -> IO () 

getLine एक IO क्रिया है जो दुनिया को एक पैरामीटर के रूप में लेती है और एक जोड़ी (String,World) लौटाती है। आप कह सकते हैं कि getLine प्रकार एक IO String ।
हम इसे एक IO क्रिया के रूप में भी देख सकते हैं जो हमें "IO में संलग्न" स्ट्रिंग देता है।

print फ़ंक्शन भी काफी दिलचस्प है। यह एक इनपुट पैरामीटर लेता है, जो तब प्रदर्शित होता है। लेकिन वास्तव में इसके दो मापदंड हैं। पहला पैरामीटर वह मान है जो प्रदर्शित किया जाएगा, दूसरा दुनिया की स्थिति है। नतीजतन, यह एक जोड़ी ((),World) । यही है, यह दुनिया की स्थिति को बदलता है, लेकिन कोई डेटा वापस नहीं करता है।

यह प्रकार bind फ़ंक्शन के लिए टाइप परिभाषा को सरल करेगा:

 bind :: IO a -> (a -> IO b) -> IO b 

bind तर्क के रूप में 2 IO कार्रवाई करता है और एक अन्य IO कार्रवाई लौटाता है।

अब, कुछ महत्वपूर्ण पैटर्न ताज़ा करें। पहला इस तरह था:

 let (x,w1) = action1 w0 in let (y,w2) = action2 x w1 in (y,w2) 

प्रकारों पर ध्यान दें:

 action1 :: IO a action2 :: a -> IO b (y,w2) :: IO b 

परिचित लगता है, है ना?

 (bind action1 action2) w0 = let (x, w1) = action1 w0 (y, w2) = action2 x w1 in (y, w2) 

मूल विचार इस फ़ंक्शन का उपयोग करके विश्व पैरामीटर को छिपाना है। चलो चलते हैं! यहाँ कुछ चीजें हैं जिन्हें हम प्राप्त करना चाहते हैं:

 let (line1,w1) = getLine w0 in let ((),w2) = print line1 in ((),w2) 

और अब, हम बाइंड फ़ंक्शन का उपयोग करते हैं:

 (res,w2) = (bind getLine (\l -> print l)) w0 

चूंकि प्रिंट प्रकार का है (World -> ((),World)) , हम जानते हैं कि res = () (अशक्त प्रकार)।
यदि आपको यहां कोई विशेष स्ट्रीट मैजिक दिखाई नहीं देता है, तो तीन-लाइन प्रोग्राम लिखने का प्रयास करें।

 let (line1,w1) = getLine w0 in let (line2,w2) = getLine w1 in let ((),w3) = print (line1 ++ line2) in ((),w3) 

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

 (res,w3) = bind getLine (\line1 -> bind getLine (\line2 -> print (line1 ++ line2))) 

क्या आपने अभी गौर किया है?
हाँ, अब और नहीं विश्व अस्थायी चर!
यह एम.ए. जीआई । मैं हूं

लेकिन हम एक अलग सिंटैक्स का उपयोग कर सकते हैं।
आइए bind को प्रतिस्थापित करें (>>=) ।
(>>=) यह एक infix फंक्शन है, जैसा कि
(+) ; याद 3 + 4 ⇔ (+) 3 4

 (res,w3) = getLine >>= \line1 -> getLine >>= \line2 -> print (line1 ++ line2) 

हो हो हो! सभी को नया साल मुबारक हो! हास्केल में हमारे लिए सिंटेक्स चीनी है:

 do x <- action1 y <- action2 z <- action3 ... 

द्वारा प्रतिस्थापित किया जा सकता है:

 action1 >>= \x -> action2 >>= \y -> action3 >>= \z -> ... 

आप action2 में x और action2 में y साथ x का उपयोग कर सकते हैं।

लेकिन उन स्ट्रिंग्स के बारे में क्या जो <- उपयोग नहीं करते हैं?
आराम से! हमारे पास एक blindBind कार्य है:

 blindBind :: IO a -> IO b -> IO b blindBind action1 action2 w0 = bind action (\_ -> action2) w0 

मैंने जानबूझकर इस अभिव्यक्ति को सरल नहीं बनाया।
बेशक, यदि हम कोड को सरल बनाना चाहते हैं, तो हम ऑपरेटर (>>) उपयोग कर सकते हैं।

और ऐसा है

 do action1 action2 action3 

में बदल जाता है

 action1 >> action2 >> action3 

वैसे, यहाँ एक और काफी उपयोगी विशेषता है:

 putInIO :: a -> IO a putInIO x = IO (\w -> (x,w)) 

यह शुद्ध मानों को "IO संदर्भ" में धकेलने का मानक तरीका है।
आमतौर पर putInIO को return कहा जाता है।
हास्केल सीखने पर यह फ़ंक्शन नाम बहुत भ्रमित है। return अन्य भाषाओं में साथियों से बहुत अलग है।

---

03_हेल / 01_IO / 21_Detailled_IO.lhs

अंत में, आइए हमारे उदाहरण को फिर से लिखें:

 askUser :: IO [Integer] askUser = do putStrLn "  ,  :" input <- getLine let maybeList = getListFromString input in case maybeList of Just l -> return l Nothing -> askUser main :: IO () main = do list <- askUser print $ sum list 

के रूप में फिर से लिखा जा सकता है:

 import Data.Maybe maybeRead :: Read a => String -> Maybe a maybeRead s = case reads s of [(x,"")] -> Just x _ -> Nothing getListFromString :: String -> Maybe [Integer] getListFromString str = maybeRead $ "[" ++ str ++ "]" askUser :: IO [Integer] askUser = putStrLn "  ,  :" >> getLine >>= \input -> let maybeList = getListFromString input in case maybeList of Just l -> return l Nothing -> askUser main :: IO () main = askUser >>= \list -> print $ sum list 

अब आप इस कोड को यह सुनिश्चित करने के लिए संकलित कर सकते हैं कि यह काम करता है।

और अब, आइए कल्पना करें कि यह सब बिना (>>) और (>>=) कैसे दिखेगा।

03_हेल / 01_IO / 21_Detailled_IO.lhs

---

03_हेल / 02_Monads / 10_Monads.lhs

इकाई

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

महत्वपूर्ण नोट :

• जरूरी नहीं कि दुष्प्रभाव साइड इफेक्ट्स से जुड़े हों!
  कई शुद्ध मठ हैं।
• मठों का सार गणना की संरचना में है

हास्केल भाषा के संदर्भ में, Monad एक प्रकार का वर्ग है।
इस वर्ग का एक उदाहरण बनने के लिए, आपको फ़ंक्शन (>>=) को परिभाषित करने और return ।
फ़ंक्शन (>>) स्वचालित रूप से (>>=) आधार पर बनाया जाएगा।
यहाँ Monad वर्ग की परिभाषा (लगभग पूर्ण) है:

 class Monad m where (>>=) :: ma -> (a -> mb) -> mb return :: a -> ma (>>) :: ma -> mb -> mb f >> g = f >>= \_ -> g --         --         fail :: String -> ma fail = error 

टिप्पणी:

• class कीवर्ड वह नहीं है जो आप सोचते हैं।
  हास्केल में एक वर्ग ओओपी से एक वर्ग नहीं है ।
  हास्केल में एक वर्ग जावा या सी # में एक इंटरफ़ेस की तरह है।
  इसे typeclass बेहतर होगा।
  जिसका अर्थ है बहुत सारी कक्षाएं।
  इस वर्ग से संबंधित प्रकार के लिए, प्रकार को कक्षा के सभी कार्यों को लागू करना चाहिए।
• इस विशेष मामले में, टाइप m एक प्रकार का होना चाहिए जो एक तर्क ले सकता है।
  उदाहरण के लिए IO a , साथ ही साथ Maybe a , [a] इत्यादि।
• एक उपयोगी मोनाद होने के लिए, आपके कार्य को कुछ कानूनों का पालन करना चाहिए।
  यदि आपका कार्य इन कानूनों का उल्लंघन करता है, तो अजीब चीजें घटित होंगी:
  

   return a >>= k == ka m >>= return == m m >>= (\x -> kx >>= h) == (m >>= k) >>= h 

  
  

शायद सन्यासी है

कई प्रकार हैं जो Monad उदाहरण हैं।
Maybe सबसे सरल उदाहरण है।
यदि आपके पास Maybe मानों का एक सेट है, तो आप उनके साथ काम करने के लिए साधुओं का उपयोग कर सकते हैं। विशेष रूप से, यह नेस्टेड से छुटकारा पाने के लिए उपयोगी हो सकता है if..then..else..

एक जटिल बैंकिंग ऑपरेशन की कल्पना करें, आप केवल if०० के बोनस का दावा कर सकते हैं यदि आपके पास ऋणों में जाने के बिना लेनदेन का इतिहास है।

 deposit value account = account + value withdraw value account = account - value eligible :: (Num a,Ord a) => a -> Bool eligible account = let account1 = deposit 100 account in if (account1 < 0) then False else let account2 = withdraw 200 account1 in if (account2 < 0) then False else let account3 = deposit 100 account2 in if (account3 < 0) then False else let account4 = withdraw 300 account3 in if (account4 < 0) then False else let account5 = deposit 1000 account4 in if (account5 < 0) then False else True main = do print $ eligible 300 -- True print $ eligible 299 -- False 

03_हेल / 02_Monads / 10_Monads.lhs

---

03_हेल / 02_Monads / 11_Monads.lhs

और अब आइए शायद इस कोड में चीजों को क्रम में रखें और शायद इसकी मोनड इकाई का उपयोग करें:

 deposit :: (Num a) => a -> a -> Maybe a deposit value account = Just (account + value) withdraw :: (Num a,Ord a) => a -> a -> Maybe a withdraw value account = if (account < value) then Nothing else Just (account - value) eligible :: (Num a, Ord a) => a -> Maybe Bool eligible account = do account1 <- deposit 100 account account2 <- withdraw 200 account1 account3 <- deposit 100 account2 account4 <- withdraw 300 account3 account5 <- deposit 1000 account4 Just True main = do print $ eligible 300 -- Just True print $ eligible 299 -- Nothing 

03_हेल / 02_Monads / 11_Monads.lhs

---

03_हेल / 02_Monads / 12_Monads.lhs

पहले से ही बुरा नहीं है, लेकिन आप और भी बेहतर कर सकते हैं:

 deposit :: (Num a) => a -> a -> Maybe a deposit value account = Just (account + value) withdraw :: (Num a,Ord a) => a -> a -> Maybe a withdraw value account = if (account < value) then Nothing else Just (account - value) eligible :: (Num a, Ord a) => a -> Maybe Bool eligible account = deposit 100 account >>= withdraw 200 >>= deposit 100 >>= withdraw 300 >>= deposit 1000 >> return True main = do print $ eligible 300 -- Just True print $ eligible 299 -- Nothing 

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

महत्वपूर्ण नोट:

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

आप Maybe लिए परिभाषा (>>=) का उपयोग करके इस कोड को फिर से लिख सकते हैं
:

 instance Monad Maybe where (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b Nothing >>= _ = Nothing (Just x) >>= f = fx return x = Just x 

Maybe कि इतने छोटे उदाहरण में भी मोनाड उपयोगी साबित हुआ Maybe । हमने मोनो IO के उपयोग को भी देखा। लेकिन एक और दिलचस्प उदाहरण है - सूचियां।

03_हेल / 02_Monads / 12_Monads.lhs

---

03_हेल / 02_Monads / 13_Monads.lhs

सनद रहे

सूची मोनड हमें गैर-नियतात्मक संगणना को मॉडल करने की अनुमति देता है।
उदाहरण के लिए:

 import Control.Monad (guard) allCases = [1..10] resolve :: [(Int,Int,Int)] resolve = do x <- allCases y <- allCases z <- allCases guard $ 4*x + 2*y < z return (x,y,z) main = do print resolve 

एमए। सैनिक। हां:

 [(1,1,7),(1,1,8),(1,1,9),(1,1,10),(1,2,9),(1,2,10)] 

सूची में मोनाड के लिए सिंथेट्रिक शुगर भी है:

  print $ [ (x,y,z) | x <- allCases, y <- allCases, z <- allCases, 4*x + 2*y < z ] 

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

• आईओ,
• गैर-नियतात्मक कंप्यूटिंग,
• छद्म यादृच्छिक संख्या उत्पन्न करना,
• विन्यास भंडारण
• राज्यों के साथ काम करें
• ...

यदि आप इस जगह पर आते हैं, तो बधाई!
अब आप कुंग फू साधुओं को जानते हैं ! (बेशक, आपको उनकी आदत डालने के लिए अभ्यास की आवश्यकता होगी। अपने खुद के एक जोड़े को लिखें। लेकिन आपने पहले से ही इस दिशा में एक बड़ा कदम उठाया है)

03_हेल / 02_Monads / 13_Monads.lhs

आवेदन

यह खंड हास्केल के अध्ययन पर सीधे लागू नहीं होता है। हम सिर्फ कुछ विवरणों पर अधिक ध्यान देते हैं।

---

04_Appendice / 01_More_on_infinite_trees / 10_Infinite_Trees.lhs

अंतहीन पेड़ों के बारे में एक और बात

अनंत संरचना खंड में, हमने सरल अनंत संरचनाओं के एक जोड़े को देखा है। दुर्भाग्य से, हमारे पेड़ ने दो गुण खो दिए हैं:

1. ट्री नोड्स में कोई डुप्लिकेट नहीं है
2. पेड़ का आदेश दिया

इस खंड में, हम पहले संपत्ति से निपटेंगे।
दूसरे के संबंध में, हम इसे थोड़ा कमजोर कर देंगे, लेकिन आदर्श के जितना करीब हो सके उतनी कोशिश करें।

शुरू करने के लिए, छद्म यादृच्छिक संख्याओं के समूह से एक सूची बनाएँ:

 shuffle = map (\x -> (x*3123) `mod` 4331) [1..] 

स्मृति को ताज़ा करने के लिए, कार्यान्वयन को डुप्लिकेट करें treeFromList

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

और treeTakeDepth:

 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 = do putStrLn "take 10 shuffle" print $ take 10 shuffle putStrLn "\ntreeTakeDepth 4 (treeFromList shuffle)" print $ treeTakeDepth 4 (treeFromList shuffle) 

 % runghc 02_Hard_Part/41_Infinites_Structures.lhs take 10 shuffle [3123,1915,707,3830,2622,1414,206,3329,2121,913] treeTakeDepth 4 (treeFromList shuffle) < 3123 : |--1915 : | |--707 : | | |--206 : | | `--1414 : | `--2622 : | |--2121 : | `--2828 : `--3830 : |--3329 : | |--3240 : | `--3535 : `--4036 : |--3947 : `--4242 

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

उदाहरण के लिए:

 treeTakeDepth 4 (treeFromList [1..]) 

अंतहीन रूप से निष्पादित किया जाएगा।
ऐसा इसलिए है क्योंकि कोड अभिव्यक्ति का प्रमुख पाने की कोशिश कर रहा है filter (<1) [2..]।
लेकिन filterयह समझने में इतना स्मार्ट नहीं है कि अभिव्यक्ति का परिणाम एक खाली सूची है।

हालांकि, यह एक अच्छा उदाहरण है कि गैर-सख्त कार्यक्रम क्या कर सकते हैं।

पाठक के लिए व्यायाम करें:

• ऐसी संख्या के अस्तित्व को साबित करें nकि यह treeTakeDepth n (treeFromList shuffle)एक अनंत लूप में आती है।
• के लिए ऊपरी सीमा का पता लगाएं n।
• साबित करें कि ऐसी कोई shuffleसूची नहीं है, जिसे निष्पादित करके, कार्यक्रम समाप्त हो जाएगा।

04_Appendice / 01_More_on_infinite_trees / 10_Infinite_Trees.lhs

---

04_Appendice / 01_More_on_infinite_trees / 11_Infinite_Trees.lhs

थोड़ा यह पता लगाने को संशोधित
treeFromListऔर shuffleइस समस्या से छुटकारा पाने के।

पहली समस्या हमारे कार्यान्वयन में यादृच्छिक संख्याओं की कमी है shuffle।
हमने केवल 4331अलग-अलग संख्याएँ उत्पन्न कीं।
हमारे कार्य में सुधार करें shuffle।

 shuffle = map rand [1..] where rand x = ((px) `mod` (x+c)) - ((x+c) `div` 2) px = m*x^2 + n*x + o -- some polynome m = 3123 n = 31 o = 7641 c = 1237 

फ़ंक्शन का यह संस्करण अच्छा है क्योंकि (मुझे पूरी उम्मीद है) मूल्यों पर एक ऊपरी और निचला बाउंड नहीं है। लेकिन एक अंतहीन लूप से बचने के लिए फेरबदल में सुधार पर्याप्त नहीं है।

कड़ाई से बोलने पर, हम यह नहीं कह सकते कि सूची खाली है या नहीं filter (<x) xs।
इस समस्या को हल करने के लिए, मैं हमारे बाइनरी ट्री कार्यान्वयन को थोड़ा तोड़ दूंगा। नए कार्यान्वयन में, कुछ नोड्स के लिए निम्नलिखित शर्त पूरी नहीं होगी:

पेड़ के मूल में मूल्य की तुलना में बाएं (प्रतिक्रिया। अधिकार) के किसी भी तत्व को कड़ाई से कम (सम्मान अधिक) होना चाहिए।

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

नए संस्करण में, treeFromListहमने इसे इसके filterसाथ बदल दिया safefilter।

 treeFromList :: (Ord a, Show a) => [a] -> BinTree a treeFromList [] = Empty treeFromList (x:xs) = Node x left right where left = treeFromList $ safefilter (<x) xs right = treeFromList $ safefilter (>x) xs 

फ़ंक्शन safefilterलगभग समान है filterलेकिन अंतहीन पेड़ों को संसाधित करते समय एक अंतहीन लूप में नहीं गिरता है। यदि उसे 10,000 चरणों में उपयुक्त वस्तु नहीं मिल रही है, तो वह खोज को रद्द कर देती है।

 safefilter :: (a -> Bool) -> [a] -> [a] safefilter fl = safefilter' fl nbTry where nbTry = 10000 safefilter' _ _ 0 = [] safefilter' _ [] _ = [] safefilter' f (x:xs) n = if fx then x : safefilter' f xs nbTry else safefilter' f xs (n-1) 

कार्यक्रम चलाएं और आनन्दित हों:

 main = do putStrLn "take 10 shuffle" print $ take 10 shuffle putStrLn "\ntreeTakeDepth 8 (treeFromList shuffle)" print $ treeTakeDepth 8 (treeFromList $ shuffle) 

, .
, Haskell .
.

8 100 ,
, !


:

• deep nbTry , . .
  treeFromList .
  : ( [0,-1,-1,....,-1,1,-1,...,-1,1,...] ).
• safefilter :
  

   safefilter' fl = if filter f (take 10000 l) == []
                    then []
                    else filter fl
  

  
  , .
  
• , shuffle .
  , , 100% .
  
  (, safefilter' )
  f
  treeFromList' shuffle. .
  

 treeFromList' [] n = Empty treeFromList' (x:xs) n = Node x left right where left = treeFromList' (safefilter' (<x) xs (fn) right = treeFromList' (safefilter' (>x) xs (fn) f = ??? 

04_Appendice/01_More_on_infinite_trees/ 11_Infinite_Trees.lhs

( , )

धन्यवाद /r/haskellऔर
/r/programming।
आपकी टिप्पणियाँ अमूल्य हैं।

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