फ़ंक्शंस में फ़ंक्शंस, ऐप्लिकेंट फ़ंक्शनलर्स और मोनाड्स

यहाँ एक सरल अर्थ है:


और हम जानते हैं कि इस पर एक फ़ंक्शन कैसे लागू करें:


Brainer। तो अब चलिए कार्य को जटिल करते हैं - संदर्भ को महत्व देते हैं। अभी के लिए, आप एक बॉक्स के रूप में संदर्भ के बारे में सोच सकते हैं जहां आप एक मूल्य रख सकते हैं:


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

 data Maybe a = Nothing | Just a 

बाद में हम Just a बनाम Nothing के फंक्शन के व्यवहार में अंतर देखेंगे। लेकिन पहले, चलो फंक्शंस के बारे में बात करते हैं!

functors

जब आपके पास एक संदर्भ में एक मूल्य पैक होता है, तो आप इसे नियमित रूप से नहीं ले सकते और लागू कर सकते हैं:


और यहाँ fmap मदद करने की जल्दी में है। fmap - सड़क से एक आदमी, fmap संदर्भों के बारे में बहुत कुछ जानता है। वह पहले से ही जानता है कि किसी फ़ंक्शन को किसी संदर्भ में पैक किए गए मान पर कैसे लागू किया जाए। मान लीजिए कि आप Just 2 पर (+3) आवेदन करना चाहते हैं। fmap उपयोग करें:

 > fmap (+3) (Just 2) Just 5 

वैम! fmap ने हमें दिखाया कि यह कैसे करना है! लेकिन वह कैसे जानता है कि फ़ंक्शन को सही ढंग से कैसे लागू किया जाए?

तो वास्तव में एक फनकार क्या है?

एक फ़नकार एक प्रकार का वर्ग है । यहाँ उसकी परिभाषा है:


एक fmap एक डेटा प्रकार है, जिसके लिए यह निर्धारित किया जाता है कि fmap पर fmap कैसे fmap जाता है। और यहां बताया गया है कि fmap कैसे काम करता है:


तो हम क्या कर सकते हैं:

 > fmap (+3) (Just 2) Just 5 

और fmap जादुई रूप से इस फ़ंक्शन को लागू fmap क्योंकि Maybe है Maybe यह एक फ़नकार है। यह कैसे और Nothing करने के लिए कार्यों को लागू करने के लिए परिभाषित करता है:

 instance Functor Maybe where fmap func (Just val) = Just (func val) fmap func Nothing = Nothing 

जब हम fmap (+3) (Just 2) लिखते हैं तो पर्दे के पीछे यही होता है:


और फिर आप कहते हैं: "ठीक है, fmap , लेकिन कृपया (+3) Nothing लागू करें।"

 > fmap (+3) Nothing Nothing 

बिल ओ'रिली का शायद फ़नकार में कोई मतलब नहीं है

द मैट्रिक्स में मॉर्फियस की तरह, fmap पता है कि क्या करना है; आपने Nothing भी Nothing साथ शुरू किया और Nothing भी Nothing साथ समाप्त हो गया! यह fmap ज़ेन है। और अब यह स्पष्ट है कि Maybe डेटा प्रकार सामान्य रूप से क्यों मौजूद है। यहाँ, उदाहरण के लिए, आप बिना भाषा में डेटाबेस में लिखने के साथ कैसे काम करेंगे:

 post = Post.find_by_id(1) if post return post.title else return nil end 

हास्केल पर:

 fmap (getPostTitle) (findPost 1) 

यदि findPost कोई संदेश देता है, तो हम getPostTitle का उपयोग करके उसका शीर्ष लेख getPostTitle । अगर वह Nothing लौटाता है, तो हम Nothing लौटाते हैं! बहुत खूबसूरत, हुह?
<$> एक नया संस्करण है, तो इसके बजाय कोड के ऊपर आप अक्सर पा सकते हैं:

 getPostTitle <$> (findPost 1) 

यहां एक और उदाहरण है: जब आप किसी फ़ंक्शन को किसी सूची में लागू करते हैं तो क्या होता है?


सूचियाँ भी फंक्शनलर्स हैं! यहाँ परिभाषा है:

 instance Functor [] where fmap = map 

ठीक है, ठीक है, एक और (अंतिम) उदाहरण: जब आप किसी फ़ंक्शन को दूसरे फ़ंक्शन पर लागू करते हैं तो क्या होता है?

 fmap (+3) (+1) 

यहाँ समारोह है:


और यहाँ एक फ़ंक्शन दूसरे फ़ंक्शन पर लागू होता है:


परिणाम सिर्फ एक और विशेषता है!

 > import Control.Applicative > let foo = fmap (+3) (+2) > foo 10 15 

तो फ़ंक्शंस भी फ़ंक्शनल हैं!

 instance Functor ((->) r) where fmap fg = f . g 

और जब आप किसी फंक्शन में fmap , तो आप बस फंक्शन fmap करते हैं!

एप्लाइड फंक्शनल

अगला स्तर एप्लाइड फंक्शनलर्स है। उनके साथ, हमारा मूल्य अभी भी संदर्भ में पैक किया गया है (ठीक उसी तरह जैसे कि फंक्शनलर्स):


लेकिन अब हमारे कार्य को संदर्भ में पैक किया गया है!


अहा! चलो इस में प्रवेश करते हैं। एप्लाइड फंक्शनलर्स ठग में शामिल नहीं हैं। Control.Applicative एक <*> को परिभाषित करता है जो जानता है कि संदर्भ में पैक किए गए मान के संदर्भ में पैक किया गया फ़ंक्शन कैसे लागू करें:


यानी

 Just (+3) <*> Just 2 == Just 5 

<*> उपयोग करने से रोचक स्थितियां बन सकती हैं। उदाहरण के लिए:

 > [(*2), (+3)] <*> [1, 2, 3] [2, 4, 6, 4, 5, 6] 

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

 > (+) <$> (Just 5) Just (+5) > Just (+5) <$> (Just 4) ???         JUST 

आवेदक

 > (+) <$> (Just 5) Just (+5) > Just (+5) <*> (Just 3) Just 8 

Functor तकनीकी रूप से Functor एक तरफ धकेल देता है। "बड़े लोग किसी भी तर्क के साथ कार्यों का उपयोग कर सकते हैं," वे कहते हैं। " <$> और <*> साथ सशस्त्र, मैं किसी भी फ़ंक्शन को ले सकता हूं जो किसी भी संख्या में अनपैक तर्कों की अपेक्षा करता है। फिर मैं उसे सभी पैक्ड वैल्यू दूंगा और पैक्ड रिजल्ट दूंगा! BWAHAHAHAHAHA! "

 > (*) <$> Just 5 <*> Just 3 Just 15 

आवेदक फ़नकार देखता है कि नियमित फ़ंक्शन कैसे लागू होता है

और हाँ! एक liftA2 ए liftA2 फ़ंक्शन है जो समान कार्य करता है:

 > liftA2 (*) (Just 5) (Just 3) Just 15 

इकाई

साधु कैसे सीखें:

1. कंप्यूटर साइंस में पीएचडी क्रस्ट प्राप्त करें
2. उन्हें nafig फेंक दें, क्योंकि इस खंड को पढ़ते समय आपको उनकी आवश्यकता नहीं होगी!

मोनाड्स हमारे कथानक में एक नया मोड़ जोड़ते हैं।
फ़ंक्शंस पैक किए गए मान पर नियमित फ़ंक्शन लागू करते हैं:


आवेदक फंक्शनल पैक्ड फंक्शन को पैक्ड वैल्यू पर लागू करते हैं:


मोनाड एक फ़ंक्शन लागू करते हैं जो एक पैक मूल्य को एक पैक मूल्य पर लौटाता है । मोनाड्स का एक फ़ंक्शन है >>= (उच्चारण "बाइंडिंग" ( बाइंड )), जो आपको ऐसा करने की अनुमति देता है।
इस उदाहरण पर विचार करें: हमारा अच्छा पुराना Maybe एक सन्यासी है:

बस एक झूलता हुआ मोनाड

मान लें कि एक ऐसा फ़ंक्शन है जो केवल संख्याओं के साथ काम करता है:

 half x = if even x then Just (x `div` 2) else Nothing 

लेकिन क्या होगा अगर हम उसे पैक्ड वैल्यू खिलाएं?


हमें फ़ंक्शन के माध्यम से पैक मूल्य को धकेलने के लिए >>= का उपयोग करने की आवश्यकता है। ये है फोटो >>=


और यहाँ है कि यह कैसे काम करता है:

 > Just 3 >>= half Nothing > Just 4 >>= half Just 2 > Nothing >>= half Nothing 

अंदर क्या चल रहा है? Monad एक अन्य प्रकार की कक्षा है। यहाँ एक आंशिक परिभाषा है:

 class Monad m where (>>=) :: ma -> (a -> mb) -> mb 

जहाँ >>= :


तो Maybe एक सन्यासी है:

 instance Monad Maybe where Nothing >>= func = Nothing Just val >>= func = func val 

लेकिन गरीबों पर क्या कार्रवाई की जा रही है Just 3 !


यदि आप इनपुट में Nothing पास करते हैं, तो यह अभी भी सरल है:


आप कॉल की एक श्रृंखला भी लिंक कर सकते हैं:

 > Just 20 >>= half >>= half >>= half Nothing 

मस्त चीज़! और अब हम जानते हैं कि Maybe है कि Functor , Monad और Monad एक में Monad ।
अब एक और उदाहरण पर चलते हैं: IO monad:


विशेष रूप से, इसके तीन कार्य। getLine कोई तर्क नहीं लेता है और इनपुट से उपयोगकर्ता डेटा प्राप्त करता है:

 getLine :: IO String 

readFile एक स्ट्रिंग (फ़ाइल नाम) लेता है और उसकी सामग्री लौटाता है:

 readFile :: FilePath -> IO String 

putStrLn एक स्ट्रिंग लेता है और उसे प्रिंट करता है:

 putStrLn :: String -> IO () 

सभी तीन फ़ंक्शन नियमित मान लेते हैं (या बिल्कुल भी मान नहीं) और पैक्ड मान लौटाते हैं। इसलिए हम >>= का उपयोग करके उन्हें चेन कर सकते हैं!

 getLine >>= readFile >>= putStrLn 

अरे हाँ, हमारे पास मोनाद शो के लिए अग्रिम पंक्ति के टिकट हैं!
हास्केल हमें मोनाड्स के लिए कुछ सिंटैक्टिक शुगर भी प्रदान करता है, जिसे do नोटेशन कहा जाता do :

 foo = do filename <- getLine contents <- readFile filename putStrLn contents 

निष्कर्ष

1. एक फ़ंक्टर एक डेटा प्रकार है जिसे Functor प्रकार वर्ग का उपयोग करके लागू किया जाता है
2. एक ऐप्लिकेटर फ़ंक्टर एक डेटा प्रकार है, जिसे ऐप्लिकेटिव टाइप क्लास का उपयोग करके लागू किया जाता है
3. मोनाड एक डेटा प्रकार है जिसे Monad प्रकार वर्ग का उपयोग करके कार्यान्वित किया जाता है।
4. शायद सभी तीन प्रकारों का उपयोग करके कार्यान्वित किया जाता है, इसलिए यह एक ही समय में एक फ़नकार, प्रयोज्य फ़ंक्टर और मोनाड है

तीनों में क्या अंतर है?

• functor : आप fmap या <$> का उपयोग करके फ़ंक्शन को पैक किए गए मान पर लागू करते हैं
• liftA : आप पैक किए गए फ़ंक्शन को <*> या liftA का उपयोग करके पैक किए गए मान पर लागू करते हैं
• मोनाद : आप एक ऐसे फंक्शन को लागू करते हैं जो पैक्ड वैल्यू को पैक करके >>= या liftM का उपयोग करके liftM

तो, प्यारे दोस्तों (और मुझे उम्मीद है कि इस क्षण तक हम दोस्त बन गए हैं), मुझे लगता है कि हम सभी सहमत होंगे कि भिक्षु सरल और स्मार्ट आईडीईए (टीएम) हैं। और अब, हम इस गाइड के साथ गला गीला करने के बाद, मेल गिब्सन को क्यों नहीं बुलाते हैं और बोतल को खत्म करते हैं? LYAH में मोनड सेक्शन देखें। ऐसी बहुत सी चीजें हैं जिनके बारे में मैंने उल्लेख नहीं किया है, क्योंकि मीरान ने इस सामग्री को गहरा बनाने का एक उत्कृष्ट काम किया है।
यहां तक ​​कि तीन उपयोगी मोनड्स ( अनुवाद ) में और भी मोनड्स और चित्र मिल सकते हैं।

अनुवादक से:
मूल से लिंक करें: http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html मैं इसे इस तरह से लिखता हूं क्योंकि हबर कॉमरस के साथ url पर कसम खाता है।
और, निश्चित रूप से, मैं अनुवाद के संबंध में पीएम की टिप्पणियों के लिए बहुत आभारी रहूंगा।