हाल ही में, नो स्टार्च प्रेस ने ग्रेट लुक के लिए उत्कृष्ट लर्न यू हास्केल के एक मुद्रित संस्करण का उत्पादन और प्रकाशित किया है ! (ऑनलाइन संस्करण) मीरान लिपोवा द्वारा लिखित।

मैं आपको अध्याय 11 का सबसे वर्तमान अनुवाद प्रस्तुत करना चाहता हूं, जिसके लिए मूल, कोई स्टार्च प्रेस से प्रकाशन, मुद्रण के लिए अनुकूलित।

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

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

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

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

फ़नकार लौट आते हैं

जैसा कि आपने अध्याय 7 में सीखा, फंक्शनलर्स ऐसी इकाइयाँ हैं जिन्हें प्रदर्शित किया जा सकता है, जैसे सूचियाँ, Maybe मान और पेड़। हास्केल में, उन्हें Functor टाइप क्लास द्वारा वर्णित किया गया है, जिसमें केवल एक ही प्रकार की क्लास विधि होती है: fmap । fmap प्रकार का होता है fmap :: (a -> b) -> fa -> fb , जो कहता है, "मुझे एक फंक्शन दीजिए जो a और रिटर्न b लेता है और एक बॉक्स (या कई a) अंदर होता है, और मैं बॉक्स को वापस करूँगा b (या कुछ b ) अंदर। "यह बॉक्स के अंदर एक तत्व के लिए फ़ंक्शन को लागू करता है।

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

यदि हम एक प्रकार के कंस्ट्रक्टर को Functor का एक उदाहरण बनाना चाहते हैं, तो यह फॉर्म * -> * का होना चाहिए, जिसका अर्थ है कि यह एक प्रकार के पैरामीटर के रूप में बिल्कुल एक ठोस प्रकार लेता है। उदाहरण के लिए, Maybe एक उदाहरण बनाया जा सकता है, क्योंकि यह एक विशेष प्रकार के उत्पाद के लिए एक प्रकार का पैरामीटर प्राप्त करता है, जैसे कि Maybe Int या Maybe String । यदि एक प्रकार का कंस्ट्रक्टर दो पैरामीटर लेता है, Either, हमें आंशिक रूप से टाइप कंस्ट्रक्टर को तब तक लागू करना चाहिए जब तक कि यह केवल एक पैरामीटर न ले। इसलिए, हम Functor Either where नहीं लिख सकते हैं, लेकिन हम Functor (Either a) where लिख सकते हैं। तब, अगर हमने कल्पना की थी कि fmap केवल Either a साथ काम करने के लिए था, तो इसके निम्नलिखित प्रकार होंगे:

 fmap :: (b -> c) -> Either ab -> Either ac 

जैसा कि आप देख सकते हैं, Either a हिस्सा तय हो गया है क्योंकि Either a ही प्रकार के पैरामीटर को स्वीकार करता है।

मैं / हे अभिनेता के रूप में कार्य करता है

अब तक, आपने अध्ययन किया है कि कितने प्रकार हैं (सटीक होने के लिए, टाइप कंस्ट्रक्टर) Functor उदाहरण हैं: [] और Maybe , Either a , साथ ही Tree प्रकार जिसे हमने अध्याय 7 में बनाया है। आपने देखा कि आप उन्हें कैसे प्रदर्शित कर सकते हैं अच्छे के लिए कार्यों का उपयोग करना। अब IO उदाहरण पर एक नज़र डालते हैं।

यदि किसी प्रकार का मान है, तो कहें, IO String का प्रकार, इसका मतलब है कि यह एक I / O क्रिया है जो वास्तविक दुनिया में बाहर जाएगी और हमारे लिए कुछ प्रकार की स्ट्रिंग प्राप्त करेगी, जिसके परिणामस्वरूप यह फिर से वापस आ जाएगी। इस परिणाम को एक नाम से बाँधने के लिए हम <- प्रयोग कर सकते हैं। अध्याय 8 में, हमने बात की कि I / O क्रियाएं छोटे पैरों वाले बक्से की तरह कैसे दिखते हैं जो बाहर जाते हैं और बाहरी दुनिया से हमारे लिए कुछ अर्थ प्राप्त करते हैं। हम देख सकते हैं कि वे क्या लाए थे, लेकिन देखने के बाद हमें IO में मूल्य को वापस लपेटने की आवश्यकता है। पैर वाले बक्से की इस सादृश्यता को देखते हुए, आप समझ सकते हैं कि IO एक फ़नकार के रूप में कैसे कार्य करता है।

आइए देखें कि कैसे IO Functor का एक उदाहरण है। जब हम किसी फ़ंक्शन का उपयोग करके I / O क्रिया को प्रदर्शित करने के लिए fmap का उपयोग करते हैं, तो हम एक I / O कार्रवाई को वापस प्राप्त करना चाहते हैं जो वही करता है, लेकिन हमारा फ़ंक्शन इसके परिणामी मूल्य पर लागू होता है। यहाँ कोड है:

 instance Functor IO where fmap f action = do result <- action return (f result) 

I / O क्रिया को किसी चीज़ के साथ प्रदर्शित करने का परिणाम I / O क्रिया है, इसलिए हम तुरंत दो क्रियाओं को एक साथ करने और एक नया बनाने के do सिंटैक्स का उपयोग करते do । fmap के कार्यान्वयन में fmap हम एक नया I / O एक्शन बनाते हैं जो पहले I / O एक्शन को निष्पादित करता है, जिसके परिणामस्वरूप नाम result । फिर हम return (f result) । याद रखें कि return एक ऐसा फ़ंक्शन है जो I / O क्रिया बनाता है जो कुछ भी नहीं करता है, लेकिन केवल इसके परिणाम के रूप में कुछ देता है।

जो कार्रवाई ब्लॉक करता है वह हमेशा अपनी अंतिम क्रिया का परिणामी मूल्य लौटाएगा। यही कारण है कि हम return का उपयोग I / O कार्रवाई बनाने के लिए करते return जो वास्तव में कुछ भी नहीं करता है, लेकिन केवल नए I / O कार्रवाई के परिणामस्वरूप f result देता है। इस कोड के टुकड़े पर एक नज़र डालें:

 main = do line <- getLine let line' = reverse line putStrLn $ "You said " ++ line' ++ " backwards!" putStrLn $ "Yes, you really said" ++ line' ++ " backwards! 

उपयोगकर्ता को एक स्ट्रिंग के लिए संकेत दिया जाता है, और हम इसे उपयोगकर्ता को वापस देते हैं, लेकिन उलटा। यहां बताया गया है कि fmap का उपयोग करके fmap फिर से कैसे fmap :

 main = do line <- fmap reverse getLine putStrLn $ "You said " ++ line ++ " backwards!" putStrLn $ "Yes, you really said" ++ line ++ " backwards!" 

जिस तरह हम fmap reverse साथ Just "blah" प्रदर्शित कर सकते हैं, Just "blah" fmap reverse Just "halb" प्राप्त कर सकते हैं, हम getLine को fmap reverse साथ प्रदर्शित कर सकते हैं। getLine एक I / O क्रिया है जो IO String के प्रकार की होती है और इसे reverse प्रदर्शित करने से हमें I / O क्रिया मिलती है जो वास्तविक दुनिया में बाहर निकल जाएगी और एक स्ट्रिंग प्राप्त करेगी, और फिर इसके परिणाम में reverse लागू करेगी। उसी तरह से कि हम क्या Maybe बॉक्स के अंदर एक फ़ंक्शन लागू कर सकते हैं, हम फ़ंक्शन को IO बॉक्स के अंदर लागू कर सकते हैं, लेकिन इसे कुछ पाने के लिए वास्तविक दुनिया में जाने की आवश्यकता है। फिर, जब हम परिणाम को <- का उपयोग करते हुए नाम से बाँधते हैं, तो नाम उस परिणाम को दर्शाएगा जो पहले से ही लागू किया जा चुका है।

fmap (++"!") getLine I / O ऑपरेशन fmap (++"!") getLine बिलकुल getLine तरह व्यवहार करता है, सिवाय इसके कि "!" हमेशा इसके परिणाम में जोड़ा जाता है "!" अंत तक!

यदि fmap केवल IO साथ काम करता है, तो यह टाइप fmap :: (a -> b) -> IO a -> IO b । fmap एक फ़ंक्शन और I / O ऑपरेशन को स्वीकार करता है, और पुराने के समान एक नया I / O ऑपरेशन लौटाता है, सिवाय इसके कि कोई फ़ंक्शन इसमें निहित परिणाम पर लागू होता है।

यदि आप कभी भी अपने आप को ऐसी स्थिति में पाते हैं जहां आप एक फ़ंक्शन के साथ I / O ऑपरेशन के परिणाम को केवल एक फ़ंक्शन लागू करने के लिए fmap , और फिर अगला परिणाम किसी अन्य नाम को देते हैं, तो fmap का उपयोग करने पर विचार करें। यदि आप किसी फ़नकार के अंदर कुछ डेटा के लिए कई फ़ंक्शन लागू करना चाहते हैं, तो आप अपने कार्य को शीर्ष स्तर पर घोषित कर सकते हैं, एक लंबो फ़ंक्शन या आदर्श रूप से, फ़ंक्शन की एक संरचना का उपयोग कर सकते हैं:

 import Data.Char import Data.List main = do line <- fmap (intersperse '-' . reverse . map toUpper) getLine putStrLn line 

यदि हम इस कोड को चलाते हैं और वहां हैलो दर्ज करते हैं तो क्या होता है:

 $ runhaskell fmapping_io hello there EREHT- -OLLEH 

फंक्शन intersperse '-' . reverse . map toUpper intersperse '-' . reverse . map toUpper intersperse '-' . reverse . map toUpper एक स्ट्रिंग लेता है, इसे toUpper साथ प्रदर्शित करता है, इस परिणाम पर reverse लागू करता है, और फिर इस परिणाम intersperse '-' को toUpper लागू करता है। यह निम्नलिखित कोड लिखने का एक अधिक सुंदर तरीका है:

(\xs -> intersperse '-' (reverse (map toUpper xs)))

फ़ंक्शंस के रूप में कार्य

एक और Functor उदाहरण जो हम सभी समय के साथ काम कर रहे हैं (->) r । बंद करो! नरक क्या (->) r मतलब है? फ़ंक्शन r -> a का प्रकार r -> a को फॉर्म (->) ra में फिर से लिखा जा सकता है, जिस तरह हम फॉर्म में 2 + 3 लिख सकते हैं (+) 2 3 । जब हम इसे (->) ra रूप में देखते हैं, तो हम (->) कुछ अलग प्रकाश में देखते हैं। यह बस एक प्रकार का कंस्ट्रक्टर है जो दो प्रकार के पैरामीटर लेता है, जैसा कि Either करता है।

लेकिन याद रखें कि एक प्रकार के निर्माणकर्ता को बिल्कुल एक प्रकार के पैरामीटर को स्वीकार करना चाहिए ताकि उसे Functor का एक उदाहरण बनाया जा सके। यही कारण है कि हम Functor का (->) उदाहरण (->) नहीं बना सकते हैं; हालाँकि, यदि आप इसे आंशिक रूप से (->) r से पहले लागू करते हैं, तो इससे कोई समस्या नहीं होती है। यदि सिंटैक्स ने आपको अनुभागों का उपयोग करके आंशिक रूप से टाइप कंस्ट्रक्टर को लागू करने की अनुमति दी है (हम कैसे कर सकते हैं + (2+) , जो कि (+) 2 ) के समान है, तो आप (->) r as (r->) लिख सकते हैं।

फ़ंक्शन कैसे होते हैं? ठीक है, चलिए Control.Monad.Instances पर एक नज़र डालते हैं जो Control.Monad.Instances ।

 instance Functor ((->) r) where fmap fg = (\x -> f (gx)) 

आइए सबसे पहले fmap प्रकार के बारे में सोचते हैं:

 fmap :: (a -> b) -> fa -> fb 

अगला, आइए मानसिक रूप से हर f बदलें, जो कि हमारे फनकार उदाहरण की भूमिका है, (->) r । यह हमें यह समझने की अनुमति देगा कि इस विशेष उदाहरण के मामले में fmap को fmap व्यवहार करना चाहिए। यहाँ परिणाम है:

 fmap :: (a -> b) -> ((->) ra) -> ((->) rb) 

अब हम infix रूप में प्रकार (->) ra और (->) rb लिख सकते हैं, अर्थात।
r -> a और r -> b , जैसा कि हम आमतौर पर कार्यों के साथ करते हैं:

 fmap :: (a -> b) -> (r -> a) -> (r -> b) 

सब ठीक है। एक फ़ंक्शन को दूसरे फ़ंक्शन के साथ मैप करना एक फ़ंक्शन का उत्पादन करना चाहिए, जैसे मैपिंग Maybe है कि फ़ंक्शन के साथ Maybe उत्पादन करें, और फ़ंक्शन के साथ एक सूची प्रदर्शित करने से एक सूची का उत्पादन होना चाहिए। पिछला प्रकार हमें क्या बताता है? हम देखते हैं कि यह r से b तक एक फंक्शन लेता है और r से b तक एक फंक्शन देता है। क्या यह आपको कुछ याद दिलाता है? हाँ, कार्यों की एक रचना! हम आउटपुट r -> a को इनपुट a -> b को फंक्शन r -> b जोड़ने के लिए जोड़ते हैं, जो कि फंक्शन्स की रचना है। इस उदाहरण को लिखने का एक और तरीका इस प्रकार है:

 instance Functor ((->) r) where fmap = (.) 

यह कोड यह स्पष्ट करता है कि fmap को फ़ंक्शंस में लागू करना फ़ंक्शंस की एक रचना है। स्क्रिप्ट में, Control.Monad.Instances आयात करें, क्योंकि यह वह मॉड्यूल है जहां इस उदाहरण को परिभाषित किया गया है, और फिर स्क्रिप्ट लोड करें और फ़ंक्शन के प्रदर्शन के साथ खेलने का प्रयास करें:

 ghci> :t fmap (*3) (+100) fmap (*3) (+100) :: (Num a) => a -> a ghci> fmap (*3) (+100) 1 303 ghci> (*3) `fmap` (+100) $ 1 303 ghci> (*3) . (+100) $ 1 303 ghci> fmap (show . (*3)) (*100) 1 "300" 

हम इसे एक समान बनाने के लिए fmap को एक fmap फ़ंक्शन कह सकते हैं . स्पष्ट था। इनपुट की दूसरी पंक्ति में, हम (*3) की मदद से (+100) प्रदर्शित करते हैं, जो एक फ़ंक्शन देता है जो इनपुट को स्वीकार करेगा, इसे (+100) लागू करेगा, और फिर इस परिणाम (*3) । फिर हम इस फ़ंक्शन को 1 लागू करते हैं।

सभी प्रकारांतरों की तरह, कार्यों को संदर्भों के साथ मान के रूप में माना जा सकता है। जब हमारे पास एक फ़ंक्शन (+3) , तो हम फ़ंक्शन के अंतिम परिणाम के रूप में मूल्य पर विचार कर सकते हैं, और संदर्भ यह है कि परिणाम प्राप्त करने के लिए हमें इस फ़ंक्शन को किसी चीज़ पर लागू करना चाहिए। fmap (*3) से (+100) लागू करने से एक और फ़ंक्शन बनेगा जो (+100) के समान है, लेकिन परिणाम लौटने से पहले, (*3) इस परिणाम पर लागू किया जाएगा।

तथ्य यह है कि जब कार्यों के लिए लागू किया जाता है, तो fmap कार्य की एक संरचना है, इस समय बहुत उपयोगी नहीं है, लेकिन कम से कम यह बहुत दिलचस्प है। यह हमारे दिमागों को थोड़ा बदल देता है और हमें यह देखने की अनुमति देता है कि बॉक्स ( IO और (->) r ) की तुलना में गणना की तरह काम करने वाली संस्थाएं कैसे फंक्शनल हो सकती हैं। फ़ंक्शन का उपयोग करके गणना प्रदर्शित करना उसी प्रकार की गणना देता है, लेकिन फ़ंक्शन द्वारा इस गणना का परिणाम बदल जाता है।


उन कानूनों पर आगे बढ़ने से पहले, जिन्हें fmap का पालन करना चाहिए, आइए फिर से fmap प्रकार के बारे में fmap :

 fmap :: (a -> b) -> fa -> fb 

अध्याय 5 में करी कार्यों के लिए परिचय इस कथन के साथ शुरू हुआ कि हास्केल के सभी कार्य वास्तव में एक पैरामीटर लेते हैं। फ़ंक्शन a -> b -> c वास्तव में टाइप का केवल एक पैरामीटर लेता a , और फिर फ़ंक्शन b -> c लौटाता है, जो एक पैरामीटर लेता है और c लौटाता है। यही कारण है कि अपर्याप्त मापदंडों (इसके आंशिक अनुप्रयोग) के साथ एक फ़ंक्शन को कॉल करना हमारे लिए एक फ़ंक्शन देता है जो कई मापदंडों को स्वीकार करता है जिन्हें हमने छोड़ दिया था (यदि हम फिर से कार्यों को समझते हैं जैसे कि वे कई मापदंडों को स्वीकार करते हैं)। इसलिए, करी को और अधिक स्पष्ट करने के लिए a -> b -> c को a -> (b -> c) रूप में लिखा जा सकता है।

उसी नस में, अगर हम fmap :: (a -> b) -> (fa -> fb) fmap , तो हम fmap को एक फंक्शन के रूप में नहीं देख सकते हैं जो एक फंक्शन और एक फंक्शनल वैल्यू लेता है और एक फनकार वैल्यू देता है, लेकिन एक फंक्शन के रूप में जो एक फ़ंक्शन लेता है और एक नया फ़ंक्शन देता है जो पिछले एक के समान है, सिवाय इसके कि यह एक पैरामीटर के रूप में एक फ़ंक्शनल मान लेता है और परिणामस्वरूप एक फ़ंक्शनल मान लौटाता है। यह फंक्शन को a -> b लेता है और फंक्शन को fa -> fb लौटाता है। इसे "उठाने का कार्य" कहा जाता है। GHCi में :t कमांड का उपयोग करके इस विचार के साथ खेलते हैं:

 ghci> :t fmap (*2) fmap (*2) :: (Num a, Functor f) => fa -> fa ghci> :t fmap (replicate 3) fmap (replicate 3) :: (Functor f) => fa -> f [a] 

एक्सप्रेशन fmap (*2) एक ऐसा फंक्शन है जो संख्याओं पर एक फंक्शनल f लेता है और नंबरों पर एक fmap (*2) लौटाता है। यह फ़नकार एक सूची हो सकती है, Maybe , Either String , या कुछ और। एक्सप्रेशन fmap (replicate 3) किसी भी प्रकार पर एक fmap (replicate 3) प्राप्त करेगा और इस प्रकार के तत्वों की सूची में एक fmap (replicate 3) करेगा। यह और भी स्पष्ट हो जाता है अगर हम आंशिक रूप से लागू करते हैं, कहते हैं, fmap (++"!") , और फिर इसे GHCi में एक नाम से बाँधें।

आप दो तरीकों से fmap अनुभव कर सकते हैं:

• एक फ़ंक्शन के रूप में जो एक फ़ंक्शन और एक फ़ंक्शनल वैल्यू लेता है, और फिर इस फ़ंक्शन का उपयोग करके इसे फ़ंक्शनल मान पर मैप करता है
• एक फ़ंक्शन के रूप में जो एक फ़ंक्शन लेता है और इसके उठाने का कार्य करता है, ताकि यह फंक्शनलर्स के मूल्यों पर संचालित हो

दोनों ही दृष्टिकोण सही हैं।

प्रकार fmap (replicate 3) :: (Functor f) => fa -> f [a] अर्थ है कि फ़ंक्शन किसी भी फ़नकार के साथ काम करेगा। वास्तव में वह क्या करेगी, यह फ़नकार पर निर्भर है। यदि हम सूची में fmap (replicate 3) लागू करते हैं, तो सूची के लिए fmap कार्यान्वयन का चयन किया जाएगा, अर्थात बस map । अगर हम इसे Maybe a लागू करते हैं, तो यह Just replicate 3 अंदर मूल्य पर replicate 3 को लागू करेगा। यदि यह मान Nothing , तो यह Nothing बराबर रहेगा। यहाँ कुछ उदाहरण हैं:

 ghci> fmap (replicate 3) [1,2,3,4] [[1,1,1],[2,2,2],[3,3,3],[4,4,4]] ghci> fmap (replicate 3) (Just 4) Just [4,4,4] ghci> fmap (replicate 3) (Right "blah") Right ["blah","blah","blah"] ghci> fmap (replicate 3) Nothing Nothing ghci> fmap (replicate 3) (Left "foo") Left "foo" 

फनकार कानून

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

अधिनियम 1

फंक्शंस के पहले कानून में कहा गया है कि यदि हम फंक्शन फ़ंक्शन को किसी फ़नकार के मान पर लागू करते हैं, तो फ़ंक्शनल का मान जो हमें मिलता है, वह फ़नकार के मूल मूल्य के समान होना चाहिए। थोड़ा और औपचारिक रूप में, इसका मतलब है fmap id = id । अनिवार्य रूप से, यह कहता है कि यदि हम किसी fmap id के मूल्य के लिए fmap id , तो यह वैसा ही होना चाहिए जैसा कि मूल्य पर id को लागू करना है। याद रखें कि id एक पहचान फ़ंक्शन है जो बस अपने पैरामीटर को अपरिवर्तित लौटाता है। इसे \x -> x रूप में भी लिखा जा सकता है। यदि हम fmap id = id के मूल्य को किसी ऐसी चीज़ के रूप में लेते हैं जिसे प्रदर्शित किया जा सकता है, तो कानून fmap id = id बहुत तुच्छ और स्पष्ट दिखता है।

आइए देखें कि क्या यह कानून फंक्शंस के कुछ मूल्यों के लिए है।

 ghci> fmap id (Just 3) Just 3 ghci> id (Just 3) Just 3 ghci> fmap id [1..5] [1,2,3,4,5] ghci> id [1..5] [1,2,3,4,5] ghci> fmap id [] [] ghci> fmap id Nothing Nothing 

यदि हम उदाहरण के लिए, fmap के कार्यान्वयन को fmap , तो Maybe , हम समझ सकते हैं कि fmap का पहला नियम क्यों है:

 instance Functor Maybe where fmap f (Just x) = Just (fx) fmap f Nothing = Nothing 

हम कल्पना करते हैं कि id इस कार्यान्वयन में पैरामीटर f की भूमिका निभाता है। हम देख सकते हैं कि यदि हम Just x पर fmap id , तो परिणाम Just (id x) , और चूंकि id अभी अपना पैरामीटर देता है, हम यह निष्कर्ष निकाल सकते हैं कि Just (id x) Just x बराबर है। इसलिए, अब हम जानते हैं कि अगर हम Just वैल्यू कंस्ट्रक्टर का उपयोग करके बनाए गए Maybe वैल्यू पर id लगाते हैं, तो हमें वही वैल्यू वापस मिलती है।

यह देखते हुए कि Nothing करने के लिए id को लागू करना समान मूल्य है। इसलिए, fmap के कार्यान्वयन में इन दो समानताओं से fmap हम देखते हैं कि कानून fmap id = id का सम्मान किया जाता है।

अधिनियम 2

दूसरा कानून कहता है कि दो फ़ंक्शन की संरचना और फ़ंक्शनल के परिणामी फ़ंक्शन के बाद के अनुप्रयोग को फ़ंक्टर पर पहले फ़ंक्शन को लागू करने और फिर दूसरे फ़ंक्शन को लागू करने के समान परिणाम देना चाहिए। औपचारिक संकेतन में, इसका अर्थ है कि fmap (f . g) = fmap f . fmap g fmap (f . g) = fmap f . fmap g । या, यदि हम इसे अलग तरह से लिखते हैं, तो fmap (f . g) x = fmap f (fmap gx) x किसी भी मान के x निम्नलिखित को धारण करना चाहिए: fmap (f . g) x = fmap f (fmap gx) ।

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

हम यह पता लगा सकते हैं कि दूसरा कानून एक निश्चित प्रकार के लिए कैसे fmap है, जो उस प्रकार के लिए fmap कार्यान्वयन को fmap , और फिर विधि का उपयोग करके हम यह fmap कि Maybe पहले कानून का पालन करता है। इसलिए, यह जाँचने के लिए Maybe fmap (f . g) का दूसरा नियम Maybe कि कैसे Maybe , अगर हम Nothing करने के लिए fmap (f . g) लागू करते हैं, तो हमें Nothing मिलता है, क्योंकि किसी भी फ़ंक्शन को Nothing भी लागू करने से Nothing मिलता है। यदि हम fmap f (fmap g Nothing) निष्पादित fmap f (fmap g Nothing) , तो हमें उन्हीं कारणों से Nothing मिलता है।

यह देखना बहुत सरल है कि मूल्य के लिए दूसरा कानून कैसे Maybe जब मूल्य Nothing ।लेकिन क्या होगा अगर वह मूल्य Just? ठीक है, अगर हम करते हैं fmap (f . g) (Just x), हम कार्यान्वयन से देख सकते हैं कि इसे लागू किया गया है Just ((f . g) x), जो समान है Just (f (gx))। यदि हम करते हैं fmap f (fmap g (Just x)), तो हम कार्यान्वयन से देख सकते हैं कि fmap g (Just x)यह क्या है Just (gx)। इसलिए, यह fmap f (fmap g (Just x))बराबर है fmap f (Just (gx)), लेकिन कार्यान्वयन से हम देख सकते हैं कि यह बराबर है Just (f (gx))।

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

कानून का उल्लंघन

आइए एक प्रकार के कंस्ट्रक्टर के एक पैथोलॉजिकल उदाहरण को देखें, जो कि फ़न्क्टर प्रकार के वर्ग का एक उदाहरण है, लेकिन फ़नकार का नहीं, क्योंकि यह कानूनों का पालन नहीं करता है। कहें कि हमारे पास निम्न प्रकार हैं:

 data CMaybe a = CNothing | CJust Int a deriving (Show) 

Cयहाँ काउंटर के लिए खड़ा है। यह एक डेटा प्रकार है जो शायद बहुत कुछ दिखता है, केवल एक हिस्से Justमें एक के बजाय दो फ़ील्ड होते हैं। मूल्य निर्माता में पहला क्षेत्र CJustहमेशा एक प्रकार का होगा Int, और यह एक प्रकार का काउंटर होगा। और दूसरे क्षेत्र में एक प्रकार aहोता है जिसे टाइप पैरामीटर से लिया जाता है, और इसका प्रकार उस विशिष्ट प्रकार पर निर्भर करेगा जिसे हम चुनते हैं CMaybe a। चलो हमारे नए प्रकार के साथ खेलते हैं:

 ghci> CNothing CNothing ghci> CJust 0 "haha" CJust 0 "haha" ghci> :t CNothing CNothing :: CMaybe a ghci> :t CJust 0 "haha" CJust 0 "haha" :: CMaybe [Char] ghci> CJust 100 [1,2,3] CJust 100 [1,2,3] 

यदि हम कंस्ट्रक्टर का उपयोग करते हैं CNothing, तो इसमें कोई फ़ील्ड नहीं है। यदि हम कंस्ट्रक्टर का उपयोग करते हैं CJust, तो पहला फ़ील्ड एक पूर्णांक है, और दूसरा किसी भी प्रकार का हो सकता है। चलो इस प्रकार का एक उदाहरण बनाते हैं Functor, ताकि हर बार जब हम उपयोग करते हैं fmap, तो फ़ंक्शन दूसरे फ़ील्ड पर लागू होता है, और पहले फ़ील्ड द्वारा बढ़ाया जाता है 1।

 instance Functor CMaybe where fmap f CNothing = CNothing fmap f (CJust counter x) = CJust (counter+1) (fx) 

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

 ghci> fmap (++"ha") (CJust 0 "ho") CJust 1 "hoha" ghci> fmap (++"he") (fmap (++"ha") (CJust 0 "ho")) CJust 2 "hohahe" ghci> fmap (++"blah") CNothing CNothing 

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

 ghci> fmap id (CJust 0 "haha") CJust 1 "haha" ghci> id (CJust 0 "haha") CJust 0 "haha" 

जैसा कि फंक्शनलर्स का पहला नियम कहता है, यदि हम फंटर के मान को आईडी के साथ प्रदर्शित करते हैं, तो यह वैसा ही होना चाहिए जैसा idफनकार के समान मूल्य के साथ होता है। हमारे उदाहरण से पता चलता है कि यह हमारे फ़नकार पर लागू नहीं होता है CMaybe। यद्यपि यह प्रकार वर्ग का हिस्सा है Functor, यह फंक्शंस के दिए गए कानून का पालन नहीं करता है और इसलिए, यह एक फ़नकार नहीं है।

चूँकि CMaybeयह एक फ़नकार नहीं है, हालाँकि यह एक होने का ढोंग करता है, फ़नकार के रूप में इसका उपयोग करने से दोषपूर्ण कोड हो सकता है। जब हम किसी फ़ंक्टर का उपयोग करते हैं, तो यह महत्वपूर्ण नहीं है कि हम पहली बार कई फ़ंक्शंस की रचना करते हैं, और फिर फ़नकार के मान को प्रदर्शित करने के लिए इसका उपयोग करते हैं, या क्या हम प्रत्येक फ़ंक्शन के साथ फंक्शनल फ़ंक्शनल के मान को प्रदर्शित करते हैं। लेकिन उपयोग करते समयCMaybeयह मायने रखता है, क्योंकि यह ट्रैक करता है कि इसे कितनी बार प्रदर्शित किया गया है। शांत नहीं! यदि हम CMaybeफंक्शंस के नियमों का पालन करना चाहते हैं , तो हमें यह सुनिश्चित करना चाहिए कि जब हम इसका उपयोग करते हैं तो इंट फ़ील्ड नहीं बदलता है fmap।

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

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

एप्लाइड फंक्शनलर्स का उपयोग करना

इस सेक्शन में, हम उन एप्लाइड फंक्शनलर्स पर विचार करते हैं जो एक्सटेंडेड फंक्शनलर्स हैं।

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

यदि हमारे पास है Just 3और हम कर रहे हैं fmap (*) (Just 3), तो हमें क्या मिलेगा? उदाहरण के Maybeलिए कार्यान्वयन से , Functorहम जानते हैं कि यदि यह मान है Just, तो फ़ंक्शन को मान के अंदर लागू किया जाएगा Just। इसलिए, निष्पादन fmap (*) (Just 3)वापस आ जाएगा Just ((*) 3), जिसे Just (3 *)यदि हम अनुभागों का उपयोग करते हैं तो फॉर्म में भी लिखा जा सकता है । दिलचस्प!हम एक समारोह में लिपटे हो Just!

यहाँ फ़ंक्शनल मान के अंदर कुछ और कार्य दिए गए हैं:

 ghci> :t fmap (++) (Just "hey") fmap (++) (Just "hey") :: Maybe ([Char] -> [Char]) ghci> :t fmap compare (Just 'a') fmap compare (Just 'a') :: Maybe (Char -> Ordering) ghci> :t fmap compare "A LIST OF CHARS" fmap compare "A LIST OF CHARS" :: [Char -> Ordering] ghci> :t fmap (\xyz -> x + y / z) [3,4,5,6] fmap (\xyz -> x + y / z) [3,4,5,6] :: (Fractional a) => [a -> a -> a] 

यदि हम उन वर्णों की सूची प्रदर्शित करते हैं जिनकी सहायता से compareएक प्रकार है (Ord a) => a -> a -> Ordering, तो हमें प्रकार के कार्यों की एक सूची मिलती है Char -> Ordering, क्योंकि compareसूची में वर्णों का उपयोग करके फ़ंक्शन को आंशिक रूप से लागू किया जाता है। यह प्रकार के कार्यों की सूची नहीं है (Ord a) => a -> Ordering, क्योंकि पहले आवेदन aमें एक प्रकार था Char, और इसलिए दूसरे aको यह तय करना होगा कि क्या एक प्रकार है Char।

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

 ghci> let a = fmap (*) [1,2,3,4] ghci> :ta a :: [Integer -> Integer] ghci> fmap (\f -> f 9) a [9,18,27,36] 

लेकिन क्या होगा यदि हमारे पास एक फंक्शनल वैल्यू Just (3 *)और एक फंक्शनल वैल्यू है Just 5, और हम Just (3 *)इसके साथ एक फंक्शन निकालना चाहते हैं और इसे इसके साथ प्रदर्शित करना Just 5चाहते हैं? साधारण फ़ंक्शनलर्स के साथ, यह काम नहीं करेगा, क्योंकि वे केवल साधारण फ़ंक्शंस का उपयोग करके मौजूदा फ़ंक्शनलर्स के प्रदर्शन का समर्थन करते हैं। यहां तक ​​कि जब हमने एक फ़ंक्टर के साथ फ़ंक्शंस \f -> f 9प्रदर्शित किए, तो हमने इसे एक नियमित फ़ंक्शन के साथ प्रदर्शित किया। लेकिन जो हमें प्रदान करता है fmap, उसका उपयोग करके , हम एक फ़ंक्शन की मदद से, जो कि फ़न्क्टर के मूल्य के अंदर है, फ़नकार के दूसरे मान को प्रदर्शित नहीं कर सकता है। हम निर्माणकर्ता Justको नमूने से इसके कार्यों को निकालने के लिए मिलान कर सकते हैं , और फिर इसका उपयोग करके इसे प्रदर्शित कर सकते हैं Just 5, लेकिन हम अधिक सामान्य और सार दृष्टिकोण की तलाश कर रहे हैं जो कि फंक्शंस के साथ काम करता है।

आवेदक फंक्शंस को शुभकामनाएं दें

मॉड्यूल में स्थित आवेदन प्रकार वर्ग से मिलो Control.Applicative। यह दो कार्यों को परिभाषित करता है: pureऔर <*>। यह इन कार्यों में से किसी के लिए एक डिफ़ॉल्ट कार्यान्वयन प्रदान नहीं करता है, इसलिए हमें दोनों को परिभाषित करना होगा यदि हम कुछ चाहते हैं कि एक आवेदक अंतिम संस्कार हो। इस वर्ग को इस तरह परिभाषित किया गया है:

 class (Functor f) => Applicative f where pure :: a -> fa (<*>) :: f (a -> b) -> fa -> fb 

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

पहली विधि जिसे वह परिभाषित करता है उसे कहा जाता है pure। उसका प्रकार विज्ञापन जैसा दिखता है pure :: a -> fa।fऐप्लिकेटर फ़ंक्टर के हमारे उदाहरण की भूमिका निभाता है। चूंकि हास्केल में एक बहुत अच्छी प्रकार की प्रणाली है, और चूंकि एक फ़ंक्शन कर सकता है, कुछ पैरामीटर प्राप्त कर सकते हैं और कुछ मूल्य वापस कर सकते हैं, हम प्रकार की घोषणा के बारे में बहुत कुछ कह सकते हैं, और यह प्रकार कोई अपवाद नहीं है।

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

समारोह <*>वास्तव में दिलचस्प है। उसकी इस प्रकार की परिभाषा है:

 f (a -> b) -> fa -> fb 

क्या यह आपको कुछ याद दिलाता है? ऐसा लग रहा है fmap :: (a -> b) -> fa -> fb। आप फ़ंक्शन <*>को एक प्रकार की विस्तारित के रूप में देख सकते हैं fmap। जबकि यह fmapएक फ़ंक्शन और एक फ़ंक्शनल वैल्यू लेता है, और फ़ंक्शनल वैल्यू के अंदर एक फ़ंक्शन लागू करता है, एक फ़ंक्शनल वैल्यू <*>लेता है जिसमें एक फ़ंक्शन होता है, और दूसरा फ़ंक्शंस होता है, और इस फ़ंक्शन को पहले फ़नकार से निकालता है, फिर इसके साथ दूसरा फ़नकार प्रदर्शित करता है।

ऐप्लिकेटर फ़ंक्टर शायद

के उदाहरण कार्यान्वयन पर एक नज़र डालते हैं Applicativeके लिए Maybe:

 instance Applicative Maybe where pure = Just Nothing <*> _ = Nothing (Just f) <*> something = fmap f something 

फिर से, हम उस वर्ग की परिभाषा से देखते हैं f, जो एक ऐप्लिकेटर फ़ंक्टर की भूमिका निभाता है, एक पैरामीटर के रूप में एक विशिष्ट प्रकार लेना चाहिए, इसलिए हम Applicative Maybe whereइसके बजाय उदाहरण लिखते हैं instance Applicative (Maybe a) where।

अगला, हमारे पास है pure। याद रखें कि एक फ़ंक्शन को किसी चीज़ को स्वीकार करना चाहिए और इसे एक आवेदन मूल्य में लपेटना चाहिए। हमने लिखा pure = Justक्योंकि मूल्य निर्माता Justसामान्य कार्य प्रतीत होते हैं। हम भी लिख सकते थे pure x = Just x।

अंत में, हमारे पास एक परिभाषा है <*>। हम एक फ़ंक्शन नहीं निकाल सकते Nothing, क्योंकि इसके अंदर कोई फ़ंक्शन नहीं है। इसलिए, हम कहते हैं कि यदि हम किसी फ़ंक्शन को निकालने का प्रयास करते हैं Nothing, तो परिणाम होगा Nothing। वर्ग

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

चलिए अब इसे आजमाते हैं:

 ghci> Just (+3) <*> Just 9 Just 12 ghci> pure (+3) <*> Just 10 Just 13 ghci> pure (+3) <*> Just 9 Just 12 ghci> Just (++"hahah") <*> Nothing Nothing ghci> Nothing <*> Just "woot" Nothing 

आपको लगता है कि के कार्यान्वयन को देख सकते हैं pure (+3)और Just (+3)इस मामले में - यह एक ही बात है। उपयोग करें pureयदि आप Maybeएक आवेदन के संदर्भ में मूल्यों के साथ काम कर रहे हैं (उनका उपयोग करें <*>); अन्यथा उपयोग करने के लिए छड़ी Just।

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

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

आवेदन शैली

एक प्रकार की कक्षा का उपयोग करते समय, Applicativeहम एक फ़ंक्शन के उपयोग को एक <*>श्रृंखला में रख सकते हैं , जो हमें आसानी से एक बार में कई आवेदक मूल्यों के साथ काम करने की अनुमति देता है, और केवल एक के साथ नहीं। उदाहरण के लिए, इस पर एक नज़र डालें:

 ghci> pure (+) <*> Just 3 <*> Just 5 Just 8 ghci> pure (+) <*> Just 3 <*> Nothing Nothing ghci> pure (+) <*> Nothing <*> Just 5 Nothing 

हमने फ़ंक्शन +को एक एपेटिटिव मान में लपेटा , और फिर <*>इसे दो मापदंडों के साथ कॉल करने के लिए उपयोग किया , जो दोनों ही ऐप्लिकेशंस वैल्यू हैं।

आइए देखें कि यह कैसे होता है, कदम से कदम। <*>बायां-सहयोगी, जिसका अर्थ है कि:

 pure (+) <*> Just 3 <*> Just 5 

इस एक के रूप में ही:

 (pure (+) <*> Just 3) <*> Just 5 

सबसे पहले, फ़ंक्शन +को एपेरेटिव वैल्यू में रखा जाता है - इस मामले में, वह मान Maybeजिसमें फ़ंक्शन होता है। इसलिए, हमारे पास pure (+)अनिवार्य रूप से समान है Just (+)। इसके बाद, एक कॉल होता है Just (+) <*> Just 3। इसका परिणाम है Just (3+)। यह आंशिक आवेदन के कारण है। केवल 3एक फंक्शन में +अप्लाई करने से एक फंक्शन लौटता है जो एक पैरामीटर लेता है और उसमें जुड़ता है 3। अंत में, यह निष्पादित करता है Just (3+) <*> Just 5, जिसके परिणामस्वरूप रिटर्न होता है Just 8।

यह बहुत अच्छा नहीं है ?! एप्लाइड फंक्शनलर्स और एप्लिकेशनल कम्प्यूटेशनल स्टाइलpure f <*> x <*> y <*> ...आपको ऐसे फ़ंक्शन को लेने की अनुमति देता है जो उन मापदंडों की अपेक्षा करता है जो लागू नहीं होते हैं, और इस फ़ंक्शन का उपयोग कई अनुप्रयोगात्मक मानों के साथ काम करने के लिए करते हैं। एक फ़ंक्शन हम जितने चाहें उतने पैरामीटर ले सकते हैं, क्योंकि यह हमेशा आंशिक रूप से घटनाओं के बीच कदम से कदम है <*>।

यह और भी सुविधाजनक और स्पष्ट हो जाता है यदि हम इस तथ्य को ध्यान में रखते हैं कि pure f <*> xयह समान है fmap fx। यह लागू कानूनों में से एक है। हम इस अध्याय में बाद में और अधिक विस्तार से आवेदक कानूनों की जांच करेंगे, लेकिन आइए इस बारे में सोचें कि यह यहां कैसे लागू होता है।pureडिफ़ॉल्ट संदर्भ में मान डालता है। यदि हम केवल फ़ंक्शन को डिफ़ॉल्ट संदर्भ में रखते हैं और फिर इसे निकालते हैं और इसे किसी अन्य एप्लिकेशन फ़ंक्शनल के अंदर मान पर लागू करते हैं, तो यह इस फ़ंक्शन के साथ इस ऐप्लिकेटर फ़ंक्टर को प्रदर्शित करने के समान ही होगा। लिखने के बजाय pure f <*> x <*> y <*> ..., हम लिख सकते हैं fmap fx <*> y <*> ...। यही कारण है कि यह Control.Applicativeएक फ़ंक्शन को निर्यात करता है जिसे कहा जाता है <$>, जो कि fmapइन्फिक्स ऑपरेटर के रूप में सिर्फ एक फ़ंक्शन है। यहां बताया गया है कि यह कैसे परिभाषित किया गया है:

 (<$>) :: (Functor f) => (a -> b) -> fa -> fb f <$> x = fmap fx 

नोट : याद रखें कि चर प्रकार पैरामीटर नामों या अन्य मूल्यों के नामों से स्वतंत्र हैं। यहां fफ़ंक्शन में घोषणा एक वर्ग बाधा के साथ एक प्रकार का चर है, जो कहता है कि किसी भी प्रकार का निर्माणकर्ता जो प्रतिस्थापित करता fहै वह प्रकार वर्ग का हिस्सा होना चाहिए Functor। fफ़ंक्शन का मुख्य भाग उस फ़ंक्शन को दर्शाता है जिसके साथ हम प्रदर्शित होते हैं x। तथ्य यह है कि हम fदोनों चीजों का प्रतिनिधित्व करते थे इसका मतलब यह नहीं है कि वे एक ही चीज का प्रतिनिधित्व करते हैं।

उपयोग करते समय, <$>एप्लिकेशन शैली अपने सभी महिमा में प्रकट होती है, क्योंकि अब अगर हम fतीन अनुप्रयोगात्मक मूल्यों के लिए एक फ़ंक्शन लागू करना चाहते हैं, तो हम बस लिख सकते हैंf <$> x <*> y <*> z। यदि पैरामीटर सामान्य मान थे, तो हम लिखेंगे fxyz।

आइए इस पर एक नज़र डालें कि यह कैसे काम करता है। मान लीजिए कि हम मान कनेक्ट करना चाहते हैं Just "johntra"और Just "volta"एक पंक्ति एक functor के अंदर है कि में Maybe। हम यह कर सकते हैं:

 ghci> (++) <$> Just "johntra" <*> Just "volta" Just "johntravolta" 

इससे पहले कि हम देखें कि यह कैसे होता है, पिछली पंक्ति की तुलना इस से करें:

 ghci> (++) "johntra" "volta" "johntravolta" 

applicatives साथ एक साधारण समारोह में कुछ चारों ओर सिर्फ बिखराव का उपयोग करने के <$>और <*>, और अनुप्रयोगी मूल्यों के साथ काम करते हैं और एक अनुप्रयोगी मान प्रदान करेंगे। क्या यह महान नहीं है?

हमारी ओर लौटना (++) <$> Just "johntra" <*> Just "volta": पहला (++), जिसमें एक प्रकार का (++) :: [a] -> [a] -> [a]डिस्प्ले होता है Just "johntra"। यह Just ("johntra"++)एक प्रकार के रूप में एक मूल्य में परिणाम है Maybe ([Char] -> [Char])। ध्यान दें कि फ़ंक्शन (++)का पहला पैरामीटर कैसे खाया गया था और यह aमूल्यों में कैसे बदल गया Char। और अब एक अभिव्यक्ति को निष्पादित किया जाता Just ("johntra"++) <*> Just "volta"है जो फ़ंक्शन को Justअपनी सहायता से निकालता है और प्रदर्शित करता है Just "volta", जिसके परिणामस्वरूप Just "johntravolta"। यदि दो में से एक मान Nothingहोता, तो परिणाम भी होताNothing ।

सूचियों

सूचियाँ (वास्तव में एक सूची प्रकार कंस्ट्रक्टर []) , आवेदक फंक्शनल हैं। क्या आश्चर्य है! और यहाँ []एक उदाहरण है Applicative:

 instance Applicative [] where pure x = [x] fs <*> xs = [fx | f <- fs, x <- xs] 

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

यहाँ pureकार्रवाई है:

 ghci> pure "Hey" :: [String] ["Hey"] ghci> pure "Hey" :: Maybe String Just "Hey" 

के बारे में क्या <*>? यदि फ़ंक्शन का प्रकार <*>केवल सूचियों तक सीमित था, तो हमें मिलेगा (<*>) :: [a -> b] -> [a] -> [b]। यह फ़ंक्शन सूची जनरेटर के माध्यम से कार्यान्वित किया जाता है। <*>किसी तरह अपने बाएं पैरामीटर से फ़ंक्शन को निकालना चाहिए, और फिर इसकी मदद से सही पैरामीटर प्रदर्शित करें। लेकिन बाईं सूची में फ़ंक्शन नहीं हो सकते हैं, एक फ़ंक्शन या कई फ़ंक्शन शामिल हो सकते हैं, और सही सूची में कई मान भी हो सकते हैं। यही कारण है कि हम दोनों सूची से निकालने के लिए एक सूची जनरेटर का उपयोग करते हैं। हम बाईं सूची से हर संभव फ़ंक्शन को सही सूची से हर संभव मान पर लागू करते हैं। परिणामी सूची में फ़ंक्शन को बाईं सूची से दाईं ओर मान पर लागू करने के सभी संभावित संयोजन शामिल हैं।

हम <*>इस तरह की सूची के साथ उपयोग कर सकते हैं :

 ghci> [(*0),(+100),(^2)] <*> [1,2,3] [0,0,0,101,102,103,1,4,9] 

बाईं सूची में तीन फ़ंक्शन हैं, और सही सूची में तीन मान हैं, इसलिए परिणामी सूची में नौ तत्व होंगे। बाईं सूची से प्रत्येक फ़ंक्शन को दाईं ओर से प्रत्येक तत्व पर लागू किया जाता है। यदि हमारे पास दो मापदंडों को लेने वाले कार्यों की एक सूची है, तो हम इन कार्यों को दो सूचियों के बीच लागू कर सकते हैं।

निम्नलिखित उदाहरण में, हम दो सूचियों के बीच दो कार्य लागू करते हैं:

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

<*>बाएं-साहचर्य है, इसलिए इसे पहले निष्पादित किया जाता है [(+),(*)] <*> [1,2], जिसके परिणामस्वरूप उसी की एक सूची होती है [(1+),(2+),(1*),(2*)], क्योंकि बाईं ओर प्रत्येक फ़ंक्शन को दाईं ओर प्रत्येक मान पर लागू किया जाता है। फिर इसे निष्पादित [(1+),(2+),(1*),(2*)] <*> [3,4]किया जाता है जो अंतिम परिणाम देता है।

सूचियों के साथ आवेदन शैली का उपयोग करना बहुत अच्छा है!

 ghci> (++) <$> ["ha","heh","hmm"] <*> ["?","!","."] ["ha?","ha!","ha.","heh?","heh!","heh.","hmm?","hmm!","hmm."] 

, , , , .

. 100 "what" , , [1,2,3] , , , . - (+) <$> [1,2,3] <*> [4,5,6] , + , , .

सूचियों के साथ आवेदन शैली का उपयोग करना अक्सर सूची जनरेटर के लिए एक अच्छा विकल्प होता है। अध्याय 1 में, हम कामों के सभी संभावित संयोजनों को देखना चाहते थे [2,5,10]और [8,10,11]इसलिए हमने यह किया:

 ghci> [ x*y | x <- [2,5,10], y <- [8,10,11]] [16,20,22,40,50,55,80,100,110] 

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

 ghci> (*) <$> [2,5,10] <*> [8,10,11] [16,20,22,40,50,55,80,100,110] 

मेरे लिए, यह दृष्टिकोण अधिक समझने योग्य है, क्योंकि यह समझना आसान है कि हम केवल *दो गैर-नियतात्मक गणनाओं के बीच क्या कहते हैं । यदि हम इन दो सूचियों के तत्वों के सभी संभावित उत्पादों को प्राप्त करना चाहते हैं, तो बड़े 50, हम निम्नलिखित का उपयोग करेंगे:

 ghci> filter (>50) $ (*) <$> [2,5,10] <*> [8,10,11] [55,80,100,110] 

यह देखना आसान है कि pure f <*> xsसूचियों का उपयोग करते समय कॉल समकक्ष है fmap f xs। pure f- यह सरल है [f], लेकिन यह [f] <*> xsबाईं सूची में प्रत्येक फ़ंक्शन को दाईं ओर प्रत्येक मान पर लागू करेगा , लेकिन बाईं सूची में केवल एक फ़ंक्शन है, इसलिए यह एक प्रदर्शन की तरह दिखता है।

IO एक एपेक्टिव फंक्टर भी है

एक और उदाहरण Applicativeजो हमें पहले ही मिल चुका है IO। यहां बताया गया है कि यह उदाहरण कैसे लागू किया जाता है:

 instance Applicative IO where pure = return a <*> b = do f <- a x <- b return (fx) 

चूंकि सार pureएक न्यूनतम संदर्भ में मूल्य रखना है जिसमें अभी भी मूल्य शामिल है, इसलिए यह तर्कसंगत है कि pureयह सरल है return। returnI / O क्रिया बनाता है जो कुछ भी नहीं करता है। यह बिना किसी I / O ऑपरेशंस जैसे किसी टर्मिनल पर प्रिंटिंग या किसी फाइल से पढ़ने के बिना, इसके परिणाम के रूप में कुछ मूल्य देता है।

अगर मैं <*>साथ काम करने तक सीमित रहता IO, तो उसके पास एक प्रकार होता (<*>) :: IO (a -> b) -> IO a -> IO b। के मामले में, IOयह एक I / O कार्रवाई aकरता है जो एक फ़ंक्शन देता है, एक I / O क्रिया करता है, और इस फ़ंक्शन को संबद्ध करता है f। वह फिर I / O क्रिया करती है bऔर इसके परिणाम को संबद्ध करती है x। अंत में, वह फंक्शन को लागू करती हैfकश्मीर xऔर परिणाम के रूप में इस आवेदन का परिणाम देता है। इसे लागू करने के लिए, हमने यहाँ सिंटैक्स का उपयोग किया है do। (याद रखें कि वाक्यविन्यास doका सार कई I / O क्रियाएँ लेना और उन्हें एक क्रिया में एक साथ गोंद करना है।)

जब हम उपयोग करते हैं Maybeऔर, []हम फ़ंक्शन के अनुप्रयोग को <*>उसके बाएं पैरामीटर से फ़ंक्शन को निकालने और फिर इसे दाईं ओर लागू करने के रूप में देख सकते हैं। पैरामीटर। सम्मान के साथIOनिष्कर्षण वैध रहता है, लेकिन अब हमारे पास इसे अनुक्रम में रखने की अवधारणा है, क्योंकि हम दो I / O क्रिया करते हैं और उन्हें एक में गोंद करते हैं। हमें पहले I / O क्रिया से फ़ंक्शन निकालना होगा, लेकिन I / O कार्रवाई से परिणाम निकालने के लिए, बाद में प्रदर्शन करना होगा। इस पर विचार करें:

 myAction :: IO String myAction = do a <- getLine b <- getLine return $ a ++ b 

यह एक I / O क्रिया है जो उपयोगकर्ता से दो पंक्तियों के लिए पूछता है और इसके परिणाम के रूप में इन दो पंक्तियों के संघटन को वापस करता है। हमने इसे दो I / O क्रियाओं को एक साथ चिपकाकर प्राप्त किया getLineऔर return, क्योंकि हम निष्पादन के परिणाम को शामिल करने के लिए हमारी नई चिपकी I / O कार्रवाई चाहते थे a ++ b। इसे वर्तनी के लिए एक और तरीका है कि आप आवेदन शैली का उपयोग करें:

 myAction :: IO String myAction = (++) <$> getLine <*> getLine 

यह वही चीज है जो हमने पहले की थी जब हमने I / O एक्शन बनाया था जिसने दो अन्य I / O क्रियाओं के परिणामों के बीच एक फंक्शन लागू किया था। याद रखें कि getLineयह एक I / O क्रिया है जिसमें एक प्रकार है getLine :: IO String। जब हम <*>दो आवेदन मूल्यों के बीच आवेदन करते हैं, तो परिणाम एक लागू मूल्य होता है, जिससे सभी समझ में आता है।

यदि हम बॉक्स के अनुरूप वापस लौटते हैं, तो हम इसे getLineएक बॉक्स के रूप में कल्पना कर सकते हैं जो वास्तविक दुनिया में जाता है और हमें एक स्ट्रिंग लाता है। निष्पादन (++) <$> getLine <*> getLineएक और बड़ा बॉक्स बनाता है, जो टर्मिनल से तार प्राप्त करने के लिए दो बक्से को भेजता है, और फिर इन दो तारों के संघनन को इसके परिणाम के रूप में वापस करता है।

अभिव्यक्ति (++) <$> getLine <*> getLineप्रकार की हैIO String। इसका मतलब यह है कि यह अभिव्यक्ति पूरी तरह से सामान्य इनपुट-आउटपुट एक्शन है, किसी भी अन्य की तरह, परिणाम भी लौटाता है, अन्य इनपुट-आउटपुट एक्शन की तरह। यही कारण है कि हम ऐसी चीजें कर सकते हैं:

 main = do a <- (++) <$> getLine <*> getLine putStrLn $ "The two lines concatenated turn out to be: " ++ a 

एप्लाएंसिव फंक्टर के रूप में कार्य

एक और उदाहरण Applicativeहै (->) rया कार्य करते हैं। हम अक्सर आवेदन शैली में कार्यों का उपयोग नहीं करते हैं, लेकिन अवधारणा अभी भी दिलचस्प है, तो चलिए एक नज़र डालते हैं कि फ़ंक्शन आवृत्ति कैसे लागू की जाती है।

 instance Applicative ((->) r) where pure x = (\_ -> x) f <*> g = \x -> fx (gx) 

जब हम किसी वैल्यू को एक वैल्यूएटिव वैल्यू के साथ लपेटते हैं pure, तो इसका परिणाम यह होता है कि यह वैल्यू होनी चाहिए। न्यूनतम डिफ़ॉल्ट संदर्भ अभी भी इस मूल्य को परिणाम के रूप में लौटाता है। इसीलिए, किसी फ़ंक्शन के उदाहरण के कार्यान्वयन में, यह pureएक मान लेता है और एक फ़ंक्शन बनाता है जो उस पर दिए गए पैरामीटर को अनदेखा करता है और हमेशा उस मान को लौटाता है। pureउदाहरण के लिए प्रकार (->) rदिखता है pure :: a -> (r -> a)।

 ghci> (pure 3) "blah" 3 

करीने के कारण, फ़ंक्शन लागू करना बाएं-साहचर्य है, इसलिए हम कोष्ठक को छोड़ सकते हैं:

 ghci> pure 3 "blah" 3 

उदाहरण का कार्यान्वयन <*>थोडा गूढ़ है, तो आइए देखें कि कैसे एक आवेदक शैली में आवेदक के रूप में कार्यों का उपयोग किया जाए:

 ghci> :t (+) <$> (+3) <*> (*100) (+) <$> (+3) <*> (*100) :: (Num a) => a -> a ghci> (+) <$> (+3) <*> (*100) $ 5 508 

<*>दो एप्लिकेशन वैल्यू के साथ एक फंक्शन कॉल एक एपेक्टिव वैल्यू देता है, इसलिए अगर हम इसे दो फंक्शन के साथ कहते हैं, तो हमें एक फंक्शन मिलता है। यहां क्या हो रहा है? जब हम करते हैं (+) <$> (+3) <*> (*100), हम एक समारोह है कि लागू होगी बनाने के +कार्यों के परिणाम के लिए (+3)और (*100)और कहा कि मूल्य वापस। जब बुलाया जाता है (+) <$> (+3) <*> (*100) $ 5, (+3)और (*100)पहले लागू किया जाता है 5, जिसके परिणामस्वरूप 8और होता है 500। फिर इसे +मूल्यों के साथ कहा जाता है 8और 500, जिसके परिणामस्वरूप होता है 508।

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

 ghci> (\xyz -> [x,y,z]) <$> (+3) <*> (*2) <*> (/2) $ 5 [8.0,10.0,2.5] 

हम एक समारोह फ़ंक्शन को कॉल बनाने के \xyz -> [x, y, z]समारोह से वापस लौटे अंतिम प्रदर्शन परिणामों के साथ (+3), (*2)और (/2)। 5तीन कार्यों में से प्रत्येक के लिए पारित किया है, और फिर इन परिणामों के साथ बुलाया \xyz -> [x, y, z]।

नोट : यदि आप समझते हैं कि यह कैसे काम करता (->) rहै Applicative, तो यह महत्वपूर्ण नहीं है, इसलिए यदि आप इसे अभी नहीं समझते हैं तो निराशा न करें। आवेदक शैली और कार्यों के साथ खेलते हैं कि कैसे आवेदक फंक्शनलर्स के रूप में कार्यों का उपयोग करने के लिए कुछ विचार प्राप्त करें।

ज़िपित सूची

, . : <*> , .

, [(+3),(*2)] <*> [1,2] , (+3) 1 2 , (*2) 1 2 , : [4,5,2,4] . , [(+3),(*2)] <*> [1,2] , , , . . : [4,4]। आप इसकी कल्पना कर सकते हैं [1 + 3, 2 * 2]।

वह उदाहरण जो Applicativeहमें अभी तक नहीं मिला है ZipList, और वह अंदर रहता है Control.Applicative।

चूंकि एक ही प्रकार के वर्ग के लिए एक प्रकार के दो उदाहरण नहीं हो सकते हैं, एक प्रकार पेश ZipList aकिया गया था जिसमें (ZipList)एक एकल फ़ील्ड (सूची) के साथ एक कंस्ट्रक्टर है । यहाँ एक उदाहरण है:

 instance Applicative ZipList where pure x = ZipList (repeat x) ZipList fs <*> ZipList xs = ZipList (zipWith (\fx -> fx) fs xs) 

<*>पहले फ़ंक्शन को पहले मान पर लागू करता है, दूसरे फ़ंक्शन को दूसरे मान पर, आदि के साथ यह किया जाता है zipWith (\fx -> fx) fs xs। नौकरी की प्रकृति के कारण, zipWithअंतिम सूची दोनों की छोटी सूची के समान होगी।

pureयहाँ भी दिलचस्प है। वह एक मूल्य लेती है और इसे एक सूची में डालती है जिसमें वह मूल्य सरलता से दोहराया जाता है। pure "haha"वापस आ जाएगा ZipList (["haha","haha","haha"...। यह भ्रामक हो सकता है, जैसा कि आपने सीखा है कि आपको pureएक न्यूनतम संदर्भ में एक मूल्य रखना चाहिए जो अभी भी उस मूल्य को वापस करता है। और आप सोचेंगे कि किसी भी चीज की अंतहीन सूची शायद ही कम हो। लेकिन ज़िपित सूचियों का उपयोग करते समय यह समझ में आता है, क्योंकि प्रत्येक स्थिति में मूल्य का उत्पादन किया जाना चाहिए। यह कानून का अनुपालन भी करता हैpure f <*> xsसमकक्ष होना चाहिए fmap f xs। यदि कॉल pure 3केवल वापस आती है ZipList [3], तो कॉल pure (*2) <*> ZipList [1,5,10]का परिणाम होगा ZipList [2], क्योंकि दो ज़िपित सूचियों की परिणामी सूची की लंबाई दो की छोटी सूची की लंबाई है। यदि हम अनंत के साथ एक परिमित सूची को ज़िप करते हैं, तो परिणामी सूची की लंबाई हमेशा अंतिम सूची की लंबाई के बराबर होगी।

तो कैसे ज़िपित सूचियाँ एक आवेदन शैली में काम करती हैं? आइए देखते हैं। खैर, प्रकार ZipList aमें एक उदाहरण नहीं होता है Show, इसलिए हमें फ़ंक्शन getZipListका उपयोग ज़िपित सूची से कच्ची सूची निकालने के लिए करना चाहिए :

 ghci> getZipList $ (+) <$> ZipList [1,2,3] <*> ZipList [100,100,100] [101,102,103] ghci> getZipList $ (+) <$> ZipList [1,2,3] <*> ZipList [100,100..] [101,102,103] ghci> getZipList $ max <$> ZipList [1,2,3,4,5,3] <*> ZipList [5,3,1,2] [5,3,3,4] ghci> getZipList $ (,,) <$> ZipList "dog" <*> ZipList "cat" <*> ZipList "rat" [('d','c','r'),('o','a','a'),('g','t','t')] 

नोट : एक फ़ंक्शन के (,,)रूप में ही है \xyz -> (x,y,z)। इसके अलावा, एक फ़ंक्शन के (,)रूप में ही है \xy -> (x,y)।

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

लागू कानून

साधारण फंक्शनलर्स की तरह, ऐप्लीकेंट फंक्शनलर्स अपने साथ कई कानून लेकर जाते हैं। सबसे महत्वपूर्ण कानून लागू किया जाना है pure f <*> x = fmap fx। एक अभ्यास के रूप में, आप इस अध्याय में कुछ आवेदक फंक्शंस के लिए इस कानून की पूर्ति साबित कर सकते हैं। अन्य आवेदक कानून नीचे सूचीबद्ध हैं:

• pure id <*> v = v
• pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
• pure f <*> pure x = pure (fx)
• u <*> pure y = pure ($ y) <*> u

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

एपेक्टिव फ़ंक्शंस के साथ काम करने के लिए उपयोगी फ़ंक्शंस

Control.Applicativeएक फ़ंक्शन को परिभाषित करता है जिसे कहा जाता है liftA2और निम्न प्रकार है:

 liftA2 :: (Applicative f) => (a -> b -> c) -> fa -> fb -> fc 

इसे इस तरह परिभाषित किया गया है:

 liftA2 :: (Applicative f) => (a -> b -> c) -> fa -> fb -> fc liftA2 fab = f <$> a <*> b 

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

साधारण फंक्शनलर्स का उपयोग करते समय, हम केवल फ़ंक्शन का उपयोग करके एक ही फ़नकार मूल्य प्रदर्शित कर सकते हैं। आवेदक फंक्शनलर्स का उपयोग करते समय, हम फंक्शंस के कई मानों के बीच एक फ़ंक्शन लागू कर सकते हैं। फार्म में इस फ़ंक्शन के प्रकार को समझना भी दिलचस्प है (a -> b -> c) -> (fa -> fb -> fc)। जब हम इसे इस तरह से महसूस करते हैं, तो हम कह सकते हैं कि यह liftA2एक साधारण बाइनरी फ़ंक्शन लेता है और इसे एक फ़ंक्शन में अनुवाद करता है जो दो एपेटिटिव मानों के साथ काम करता है।

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

 ghci> fmap (\x -> [x]) (Just 4) Just [4] 

खैर, हम कहते हैं कि हमारे पास है Just 3और Just [4]। हम इसे कैसे प्राप्त करते हैं Just [3,4]? यह सरल है:

 ghci> liftA2 (:) (Just 3) (Just [4]) Just [3,4] ghci> (:) <$> Just 3 <*> Just [4] Just [3,4] 

स्मरण करो कि :एक फ़ंक्शन है जो एक तत्व और एक सूची लेता है और शुरुआत में उस तत्व के साथ एक नई सूची देता है। अब जब हमारे पास यह है Just [3,4], तो क्या हम इसे Just 2उत्पादन के साथ जोड़ सकते हैं Just [2,3,4]? हाँ, वे कर सकते थे। ऐसा लगता है कि हम किसी भी आवेदक के मूल्यों को एक आवेदक मूल्य में जोड़ सकते हैं, जिसमें इन आवेदक मूल्यों के परिणामों की एक सूची है।

आइए एक फ़ंक्शन को लागू करने का प्रयास करें जो अनुप्रयोग मानों की एक सूची लेता है और एक आवेदक मान लौटाता है जिसमें सूची इसके परिणामस्वरूप मूल्य के रूप में होती है। हम उसे फोन करेंगे sequenceA:

 sequenceA :: (Applicative f) => [fa] -> f [a] sequenceA [] = pure [] sequenceA (x:xs) = (:) <$> x <*> sequenceA xs 

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

मान लीजिए हम ऐसा करते हैं:

 sequenceA [Just 1, Just 2] 

परिभाषा के अनुसार, यह निम्नलिखित के बराबर है:

 (:) <$> Just 1 <*> sequenceA [Just 2] 

इसे और तोड़ते हुए, हम प्राप्त करते हैं:

 (:) <$> Just 1 <*> ((:) <$> Just 2 <*> sequenceA []) 

हम जानते हैं कि कॉल sequenceA []फ़ॉर्म में समाप्त होती है Just [], इसलिए यह अभिव्यक्ति अब इस तरह दिखाई देती है:

 (:) <$> Just 1 <*> ((:) <$> Just 2 <*> Just []) 

जो इस के समान है:

 (:) <$> Just 1 <*> Just [2] 

क्या बराबर है Just [1,2]!

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

 sequenceA :: (Applicative f) => [fa] -> f [a] sequenceA = foldr (liftA2 (:)) (pure []) 

हम बैटरी के मूल्य से शुरू करते हुए अंत से सूची से गुजरते हैं pure []। हम liftA2 (:)बैटरी और सूची के अंतिम तत्व के बीच का उपयोग करते हैं , जिसके परिणामस्वरूप एक एकल सूची के साथ एक आवेदक मूल्य होता है। तब हम liftA2 (:)वर्तमान अंतिम तत्व और वर्तमान बैटरी आदि के साथ कॉल करते हैं, जब तक कि हमारे पास केवल बैटरी ही नहीं होती है जिसमें सभी अनुप्रयोग मूल्यों के परिणामों की एक सूची होती है।

आइए हमारे फ़ंक्शन को कुछ एप्लिकेशन मानों पर लागू करने का प्रयास करें:

 ghci> sequenceA [Just 3, Just 2, Just 1] Just [3,2,1] ghci> sequenceA [Just 3, Nothing, Just 1] Nothing ghci> sequenceA [(+3),(+2),(+1)] 3 [6,5,4] ghci> sequenceA [[1,2,3],[4,5,6]] [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]] ghci> sequenceA [[1,2,3],[4,5,6],[3,4,4],[]] [] 

जब मूल्यों के साथ उपयोग किया जाता है Maybe, तो sequenceAएक मूल्य बनाता Maybeहै जिसमें एक सूची में सभी परिणाम होते हैं। यदि मूल्यों में से एक समान है Nothing, तो परिणाम भी है Nothing। यह तब शांत होता है जब आपके पास मूल्यों की एक सूची होती है Maybeऔर आप केवल उन मूल्यों में रुचि रखते हैं जब उनमें से कोई भी समान नहीं होता है Nothing।

जब फ़ंक्शन पर लागू किया जाता है, तो यह फ़ंक्शन की sequenceAसूची लेता है और एक फ़ंक्शन देता है जो एक सूची देता है। हमारे उदाहरण में, हमने एक फ़ंक्शन बनाया जो एक संख्या को एक पैरामीटर के रूप में लेता है और इसे सूची में प्रत्येक फ़ंक्शन पर लागू करता है, और फिर परिणामों की सूची लौटाता है। पैरामीटर के साथ sequenceA [(+3),(+2),(+1)] 3कॉल करेगा , - पैरामीटर के साथ , और - पैरामीटर के साथ(+3)3(+2)3(+1)3, और इन सभी परिणामों को एक सूची के रूप में वापस कर देगा।

निष्पादन (+) <$> (+3) <*> (*2)एक फ़ंक्शन बनाएगा जो एक पैरामीटर लेता है, इसे पास करता है (+3)और (*2), और फिर +इन दो परिणामों के साथ कॉल करता है । एक ही नस में, यह समझ में आता है कि यह sequenceA [(+3),(*2)]एक फ़ंक्शन बनाता है जो एक पैरामीटर लेता है और इसे सूची में सभी कार्यों को पास करता है। +फ़ंक्शन के परिणामों के साथ कॉल करने के बजाय , इस फ़ंक्शन में इन परिणामों को जमा करने के लिए एक संयोजन का :उपयोग किया जाता pure []है जो इस फ़ंक्शन का परिणाम है।

के उपयोगsequenceAउपयोगी जब हमारे पास कार्यों की सूची होती है और हम उन्हें सभी समान इनपुट देना चाहते हैं, और फिर परिणामों की सूची देखें। उदाहरण के लिए, हमारे पास एक संख्या है और हम सोच रहे हैं कि क्या यह सूची में सभी विधेयकों को संतुष्ट करता है। यहाँ ऐसा करने का एक तरीका है:

 ghci> map (\f -> f 7) [(>4),(<10),odd] [True,True,True] ghci> and $ map (\f -> f 7) [(>4),(<10),odd] True 

स्मरण करो कि प्रकार Boolऔर मानों की सूची लेता है और Trueयदि वे सभी समान हैं तो लौटते हैं True। उसी परिणाम को प्राप्त करने का दूसरा तरीका उपयोग करना है sequenceA:

 ghci> sequenceA [(>4),(<10),odd] 7 [True,True,True] ghci> and $ sequenceA [(>4),(<10),odd] 7 True 

अनुक्रम [(> ४), (<१०), विषम] एक फ़ंक्शन बनाता है जो एक संख्या लेता है और इसे सभी विधेयकों में पास करता है [(>4),(<10),odd], और बूलियन मानों की सूची लौटाता है। वह प्रकार की एक सूची बनाता है (Num a) => [a -> Bool]एक प्रकार के साथ समारोह में (Num a) => a -> [Bool]। बहुत शांत, सही?

चूंकि सूचियां सजातीय हैं, इसलिए सूची में सभी कार्य समान प्रकार के होने चाहिए। आपको एक सूची नहीं मिल सकती है [ord, (+3)], क्योंकि यह ordएक चरित्र लेता है और एक नंबर देता है, जबकि यह (+3)एक नंबर लेता है और एक नंबर देता है।

जब उपयोग किया जाता है [], तो sequenceAसूचियों की सूची लेता है और सूचियों की सूची लौटाता है। वास्तव में, यह उन सूचियों का निर्माण करता है जिनमें उन तत्वों के सभी संयोजन होते हैं जो उनमें हैं। वर्णन करने के लिए, यहाँ एक पिछले उदाहरण का उपयोग किया गया हैsequenceAऔर फिर एक सूची जनरेटर का उपयोग करके निष्पादित किया गया:

 ghci> sequenceA [[1,2,3],[4,5,6]] [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]] ghci> [[x,y] | x <- [1,2,3], y <- [4,5,6]] [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]] ghci> sequenceA [[1,2],[3,4]] [[1,3],[1,4],[2,3],[2,4]] ghci> [[x,y] | x <- [1,2], y <- [3,4]] [[1,3],[1,4],[2,3],[2,4]] ghci> sequenceA [[1,2],[3,4],[5,6]] [[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]] ghci> [[x,y,z] | x <- [1,2], y <- [3,4], z <- [5,6]] [[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]] 

(+) <$> [1,2] <*> [4,5,6]परिणामस्वरूप गैर-नियतात्मक गणना देता है x + y, जहां यह xप्रत्येक मूल्य से लेता है [1,2]और yप्रत्येक मूल्य से लेता है [4,5,6]। हम इसे एक सूची में प्रस्तुत करते हैं जिसमें सभी संभावित परिणाम शामिल हैं। इसी तरह, जब हम प्रदर्शन करते हैं sequenceA [[1,2],[3,4],[5,6]], तो परिणाम एक गैर-नियतात्मक गणना है [x,y,z], जहां यह xप्रत्येक मूल्य से लेता है [1,2]और yप्रत्येक मूल्य लेता है [3,4], आदि। इस गैर-नियतात्मक गणना के परिणाम का प्रतिनिधित्व करने के लिए, हम एक सूची का उपयोग करते हैं जहां सूची में प्रत्येक आइटम एक संभव सूची है। यही कारण है कि परिणाम सूचियों की एक सूची है।

जब I / O क्रियाओं के साथ उपयोग किया जाता है, तो sequenceAयह उसी के समान होता हैsequence! यह I / O क्रियाओं की एक सूची लेता है और एक I / O क्रिया लौटाता है जो इनमें से प्रत्येक क्रिया को निष्पादित करेगा और इन I / O क्रियाओं के परिणामों की एक सूची के रूप में शामिल होगा। ऐसा इसलिए है, क्योंकि किसी मान [IO a]को एक मान में बदलने के IO [a]लिए, I / O क्रिया बनाने के लिए जो निष्पादित किए जाने पर परिणामों की एक सूची देता है, इन सभी I / O क्रियाओं को अनुक्रम में रखा जाना चाहिए ताकि वे परिणाम के बाद एक के बाद एक निष्पादित हो सकें। । बिना किए आप I / O क्रिया का परिणाम प्राप्त नहीं कर सकते।

आइए getLineएक क्रम में तीन I / O क्रियाएं करें :

 ghci> sequenceA [getLine, getLine, getLine] heyh ho woo ["heyh","ho","woo"] 

निष्कर्ष में, आवेदक फंक्शंस न केवल दिलचस्प हैं, बल्कि वे उपयोगी भी हैं। वे हमें अलग-अलग संगणनाओं को संयोजित करने की अनुमति देते हैं - जैसे कि I / O अभिकलन, गैर-नियतात्मक संगणनाएँ, संगणनाएँ जो विफल हो सकती हैं, और इसी तरह - अनुप्रयोग शैली का उपयोग करते हुए। बस का उपयोग करना <$>और <*>, हम सामान्य कार्यों का उपयोग किसी भी संख्या में एप्लास्टिक फ़ंक्शंस के साथ समान रूप से काम करने के लिए कर सकते हैं और उनमें से प्रत्येक के शब्दार्थ का लाभ उठा सकते हैं।

---

पुस्तक के पिछले अध्यायों के अनुवाद जिन्हें पूर्ण प्रसंस्करण (संरचना और सामग्री) की आवश्यकता होती है:

1. परिचय
2. शुरुआत
3. प्रकार और प्रकार कक्षाएं
4. फ़ंक्शन सिंटैक्स
5. प्रत्यावर्तन
6. उच्च आदेश कार्य
7. मॉड्यूल
8. अपने स्वयं के प्रकार और प्रकार की कक्षाएं बनाना
9. इनपुट-आउटपुट
10. कार्यात्मक समस्या का समाधान

प्रकाशन के लिए अगली पंक्ति में मोनाडो का अध्याय है । अब तक, मुझे सामग्री में सुधार के लिए रचनात्मक टिप्पणियों की उम्मीद है। धन्यवाद!