इन सभी फंक्शनलर्स और मोनाड्स की आवश्यकता क्यों है?

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

यह लेख यह दिखाने का प्रयास है कि कार्यात्मक भाषाओं और विशेष रूप से हास्केल की शक्ति भी फंक्शनलर्स और मोनाड्स की शक्ति है।

नेट डेटा

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

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

यहाँ हम इस कार्यक्रम की रचना करते हैं:

module Main where foo = undefined --   main :: IO () main = do putStrLn "Input a: " a <- getLine --  1    putStrLn "Input b: " b <- getLine --  2    print (foo ab) --    

यह कार्यक्रम अपमानजनक है - हम उपयोगकर्ता को 2 पंक्तियों में प्रवेश करने के लिए कहते हैं, और फिर गणना का परिणाम प्रदर्शित करते हैं।
हम देखते हैं कि हमारे फ़ंक्शन फू को अभी तक परिभाषित नहीं किया गया है (यह हमेशा प्रोग्राम को क्रैश करने का कारण बनता है), हालांकि हास्केल पहले से ही हमारे कोड को संकलित कर सकता है।

अब हम अपने फ़ंक्शन को और अधिक विस्तार से लिखते हैं, केवल "स्वच्छ" डेटा का उपयोग करते हुए:

 pure1arg :: Int -> Int pure1arg = (+ 1) --   ,   1  pure2args :: Int -> Int -> Int pure2args = (+) --  ,   2  unsafe2args :: Int -> Int -> Int unsafe2args = div --   ,   2  foo :: String -> String -> Int foo ab = unsafe2args extraUnsafeE unsafeC --     ,     where unsafeA :: Int unsafeA = read a --           unsafeB :: Int unsafeB = read b --  unsafeA    unsafeC :: Int unsafeC = pure1arg unsafeB --    1     reallyUnsafeD :: Int reallyUnsafeD = pure2args unsafeA unsafeC --    2     extraUnsafeE :: Int extraUnsafeE = unsafe2args unsafeA reallyUnsafeD --    2 .  2   . 

जैसा कि आप देख सकते हैं, यह भी यहाँ स्पष्ट है, फ़ंक्शन foo अनिवार्य रूप से [कोई फर्क नहीं पड़ता] पूर्णांक विभाजन और रकम का मिश्रण है।
अधिकांश कार्यात्मक प्रोग्रामिंग भाषाएं स्वच्छ डेटा के आधार पर फ़ंक्शन बनाना आसान और सरल बनाती हैं।

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

 module Main where import Control.Exception (IOException, catch) printError :: IOException -> IO () printError = print pure2args :: Int -> Int -> Int pure2args = (+) pure1arg :: Int -> Int pure1arg = (+ 1) unsafe2args :: Int -> Int -> Int unsafe2args ab = if b == 0 then error "Error 'unsafe2args' : wrong 2nd argument = 0" --unsafe source of IOException else div ab foo :: String -> String -> Int foo ab = unsafe2args extraUnsafeE unsafeC where unsafeA :: Int unsafeA = read a --unsafe source of IOException unsafeB :: Int unsafeB = read b --unsafe source of IOException unsafeC :: Int unsafeC = pure1arg unsafeB reallyUnsafeD :: Int reallyUnsafeD = pure2args unsafeA unsafeC extraUnsafeE :: Int extraUnsafeE = unsafe2args unsafeA reallyUnsafeD main :: IO () main = do putStrLn "Input a: " a <- getLine putStrLn "Input b: " b <- getLine catch (print (foo ab)) printError --      IOException 

गंदा डेटा

हास्केल (और कई कार्यात्मक भाषाओं) में ऐसी समस्याओं का एक योग्य जवाब है।
मुख्य ताकत बीजगणितीय डेटा प्रकारों में निहित है।

यदि हम उपरोक्त उदाहरण पर विचार करते हैं, तो यह स्पष्ट है कि हमारे कार्य गिर सकते हैं।
समाधान अशक्त डेटा प्रकारों का उपयोग करना है।
एमएल भाषाओं और स्काला में इस प्रकार को Option कहा जाता है, हास्केल में इसे Maybe a कहा जाता Maybe a ।

 import Prelude hiding (Maybe) --       .       data Maybe a = Nothing | Just a deriving Show 

हम deriving हिस्से पर ध्यान नहीं देते हैं, हम सिर्फ यह कहते हैं कि हम कंपाइलर को अपने डेटा टाइप को अपने दम पर एक स्ट्रिंग में अनुवाद करने में सक्षम होने के लिए कहते हैं।
अर्थात्,

 show Nothing == "Nothing" show (Just 3) == "Just 3" 

यदि हमारे पास डेटा नहीं है, तो डेटा प्रकार Nothing नहीं है, और यदि यह है तो Just a ।
जैसा कि आप देख सकते हैं, डेटा प्रकार "गंदा" है क्योंकि इसमें अनावश्यक जानकारी शामिल है।
आइए हमारे कार्यों को अधिक सही ढंग से, अधिक सुरक्षित और बिना किसी अपवाद के फिर से लिखें।

सबसे पहले, हम उन कार्यों को प्रतिस्थापित करते हैं जो सुरक्षित एनालॉग्स के पतन का कारण बने:

 maybeResult2args :: Int -> Int -> Maybe Int maybeResult2args ab = if b == 0 then Nothing --safe else Just (div ab) ... maybeA :: Maybe Int maybeA = readMaybe a --safe maybeB :: Maybe Int maybeB = readMaybe b --safe 

अब गिरने के बजाय ये कार्य परिणाम देते हैं Nothing , यदि सब कुछ क्रम में है, तो Just ।

लेकिन हमारे पास बाकी कोड इन कार्यों पर निर्भर करते हैं। हमें लगभग सभी कार्यों को बदलना होगा, जिनमें कई बार परीक्षण किए गए हैं।

 pure2args :: Int -> Int -> Int pure2args = (+) safePure2args :: Maybe Int -> Maybe Int -> Maybe Int safePure2args ab = case a of Nothing -> Nothing Just a' -> case b of Nothing -> Nothing Just b' -> Just (pure2args a' b') pure1arg :: Int -> Int pure1arg = (+ 1) safePure1arg :: Maybe Int -> Maybe Int safePure1arg a = case a of Nothing -> Nothing Just a' -> Just (pure1arg a') maybeResult2args :: Int -> Int -> Maybe Int maybeResult2args ab = if b == 0 then Nothing else Just (div ab) foo :: String -> String -> Maybe Int foo ab = case maybeE of Nothing -> Nothing Just e -> case maybeC of Nothing -> Nothing Just c -> maybeResult2args ec where maybeA :: Maybe Int maybeA = readMaybe a maybeB :: Maybe Int maybeB = readMaybe b maybeC :: Maybe Int maybeC = safePure1arg maybeB maybeD :: Maybe Int maybeD = safePure2args maybeA maybeC maybeE = case maybeA of Nothing -> Nothing Just a1 -> case maybeD of Nothing -> Nothing Just d -> maybeResult2args a1 d printMaybe :: Show a => Maybe a -> IO () printMaybe Nothing = print "Something Wrong" printMaybe (Just a) = print a main :: IO () main = do putStrLn "Input a: " a <- getLine putStrLn "Input b: " b <- getLine printMaybe (foo ab) 

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

क्या मैं एडीटी के साथ रह सकता हूं, लेकिन समान बैचैनलिया के बिना? यह आप कर सकते हैं पता चला है।

functors

शुरुआत में, फंक्शंस बचाव के लिए आते हैं।

फंडर्स वे डेटा प्रकार होते हैं जिनके लिए fmap फ़ंक्शन मौजूद होता है।

 class Functor f where fmap :: (a -> b) -> fa -> fb 

और साथ ही इसके infix पर्याय:

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

डेटा के सभी मानों के लिए निम्न स्थितियाँ हमेशा संतुष्ट रहती हैं:

पहचान की स्थिति:
fmap id == id
रचना की स्थिति:
fmap (f . g) == fmap f . fmap g

जहां id एक पहचान समारोह है

  id :: a -> a id x = x 

और (.) - कार्यात्मक रचना

  (.) :: (b -> c) -> (a -> b) -> a -> c f . g = \x -> f (gx) 

एक fmap एक प्रकार का वर्ग है, जहाँ हमने एक विशेष fmap फंक्शन बनाया है। आइए उसके तर्कों पर गौर करें - वह एक "साफ" फ़ंक्शन a -> b लेता है, हम "गंदे" फंक्शनल वैल्यू फादर लेते हैं और हम आउटपुट पर फंक्टर मूल्य fb प्राप्त करते हैं।

Maybe डेटा प्रकार एक फ़नकार है। Maybe प्रकार के लिए एक उदाहरण (उदाहरण) बनाते हैं, ताकि फंक्शंस के नियमों का उल्लंघन न हो:

 instance Functor Maybe where fmap _ Nothing = Nothing fmap f (Just a) = Just (fa) 

हम Maybe एक फ़्यूचर के साथ एक शुद्ध फ़ंक्शन का उपयोग कैसे करते हैं? बहुत सरल:

 safePure1arg :: Maybe Int -> Maybe Int safePure1arg = fmap pure1arg 

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

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

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

यहाँ आवेदक फंक्शन्स हमारी सहायता के लिए आते हैं:

व्यावहारिक फंक्शनलर्स वे फंक्शनलर्स हैं जिनके लिए 2 फ़ंक्शंस परिभाषित किए गए हैं: pure और (<*>)

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

उनके लिए समान डेटा के किसी भी मान के लिए निम्न नियम हमेशा सही होते हैं:

पहचान की स्थिति:
pure id <*> v == v
रचना की स्थिति:
pure (.) <*> u <*> v <*> w == u <*> (v <*> w)
होमोमोर्फिज्म की स्थिति:
pure f <*> pure x == pure (fx)
विनिमय स्थिति:
u <*> pure y == pure ($ y) <*> u

फ़ंक्टर और एपेक्टिव फ़ंक्टर के बीच मुख्य अंतर यह है कि फ़ंक्टर, फ़्यूचर वैल्यू के माध्यम से एक शुद्ध कार्य करता है, जबकि एप्लिकेर फ़ंक्टर हमें फ़ंक्टर मूल्य के माध्यम से फ़ंक्टर फ़ंक्शन f (a -> b) को खींचने की अनुमति देता है।

हो सकता है कि एक ऐप्लिकेटर फ़ंक्टर है और इसे निम्नानुसार परिभाषित किया गया है:

 instance Applicative Maybe where pure = Just Nothing <*> _ = Nothing _ <*> Nothing = Nothing (Just f) <*> (Just a) = Just (fa) 

safePure2args को फिर से लिखने का समय आ गया है।
मूल रूप से, फ़ंक्शन को फिर से लिखा जाता है, पहले तर्क के लिए fmap संयोजन, और शेष तर्कों का आवेदन स्ट्रिंग:

 safePure2args :: Maybe Int -> Maybe Int -> Maybe Int safePure2args ab = pure2args <$> a <*> b 

लेकिन आप विशेष रूप से प्रयोजकीय कार्यों (सनक शैली) का उपयोग करके एक फ़ंक्शन को फिर से लिख सकते हैं - पहले हम एक "शुद्ध" फ़ंक्शन को शुद्ध रूप से लागू करते हैं, और तर्क को तार्किक रूप से स्ट्रिंग करते हैं:

 safePure2args :: Maybe Int -> Maybe Int -> Maybe Int safePure2args ab = (pure pure2args) <*> a <*> b 

अद्भुत!
हो सकता है कि हम एक ही समय में हो सकता है कि maybeE का उपयोग करके शायद maybeE फ़ंक्शन को फिर से maybeE ? अफसोस।

इकाई

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

मोनाड्स डेटा प्रकार हैं जिसके लिए return और (>>=) फ़ंक्शन मौजूद हैं।

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

इस तरह के नियम किसी भी प्रकार के मूल्यों के लिए संतुष्ट हैं:

बाईं पहचान:
return a >>= k == ka
सही पहचान:
m >>= return == m
संबद्धता:
m >>= (\x -> kx >>= h) == (m >>= k) >>= h

सुविधा के लिए, तर्कों के रिवर्स ऑर्डर के साथ एक अतिरिक्त कार्य है:

 (=<<) :: Monad m => (a -> mb) -> ma -> mb (=<<) = flip (>>=) 

जहाँ

 flip :: (a -> b -> c) -> b -> a -> c flip fab = fba 

हम समझते हैं कि Maybe प्रकार एक सन्यासी है, जिसका अर्थ है कि हम इसके उदाहरण (उदाहरण) को परिभाषित कर सकते हैं:

 instance Monad Maybe where return = Just (Just x) >>= k = kx Nothing >>= _ = Nothing 

वैसे, अगर हम आंतरिक सामग्री और हस्ताक्षर पर करीब से नज़र डालें, तो हम देखेंगे कि:
pure == return
fmap f xs == xs >>= return . f

यह maybeE फ़ंक्शन को फिर से लिखने का समय है

  maybeE = maybeA >>= (\a1 -> maybeD >>= (maybeResult2args a1)) 

हाँ, यह अधिक सुंदर नहीं निकला। ऐसा इसलिए है क्योंकि एक चर के लिए भिक्षुओं को खूबसूरती से लिखा गया है। सौभाग्य से, कई अतिरिक्त विशेषताएं हैं।
आप एक bind2 फ़ंक्शन लिख सकते हैं

 bind2 :: Monad m => (a -> b -> mc) -> ma -> mb -> mc bind2 mf mx my = do x <- mx y <- my mf xy 

  maybeE = bind2 maybeResult2args maybeA maybeD 

या फ़ंक्शन liftM2 उपयोग करें और join

 liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> mr join :: Monad m => m (ma) -> ma maybeE = join $ liftM2 maybeResult2args maybeA maybeD 

चरम मामलों में, आप नोटेशन का उपयोग करते हुए मोनाड के लिए सिंटैक्टिक शुगर का उपयोग कर सकते हैं:

  maybeE = do a1 <- maybeA d <- maybeD maybeResult2args a1 d 

पाउंड और मोनड के उपयोग में अंतर

यदि हम मुख्य कार्यों को एक रूप में घटाते हैं, तो हम देखेंगे:

 (<$>) :: Functor f => (a -> b) -> fa -> fb (<*>) :: Applicative f => f (a -> b) -> fa -> fb (=<<) :: Monad f => (a -> fb) -> fa -> fb 

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

दिनचर्या के बिना कार्यक्रम

खैर, आखिरकार, आप पूरे कार्यक्रम को पूरी तरह से और सटीक रूप से फिर से लिख सकते हैं:

 module Main where import Control.Monad import Control.Applicative import Text.Read (readMaybe) bind2 :: Monad m => (a -> b -> mc) -> ma -> mb -> mc bind2 mf mx my = do x <- mx y <- my mf xy pure2args :: Int -> Int -> Int pure2args = (+) pure1arg :: Int -> Int pure1arg = (+ 1) maybeResult2args :: Int -> Int -> Maybe Int maybeResult2args ab = if b == 0 then Nothing --safe else Just (div ab) foo :: String -> String -> Maybe Int foo ab = bind2 maybeResult2args maybeE maybeC where maybeA :: Maybe Int maybeA = readMaybe a --safe maybeB :: Maybe Int maybeB = readMaybe b --safe maybeC :: Maybe Int maybeC = fmap pure1arg maybeB maybeD :: Maybe Int maybeD = pure2args <$> maybeA <*> maybeC maybeE :: Maybe Int maybeE = bind2 maybeResult2args maybeA maybeD printMaybe :: Show a => Maybe a -> IO () printMaybe Nothing = print "Something Wrong" printMaybe (Just a) = print a main :: IO () main = do putStrLn "Input a: " a <- getLine putStrLn "Input b: " b <- getLine printMaybe (foo ab) 

कोड फिर से सरल और स्पष्ट हो गया!
उसी समय, हमने सुरक्षा का एक इंच भी नहीं छोड़ा!
हालाँकि, हमने लगभग कोड नहीं बदला है!
उसी समय, शुद्ध कार्य शुद्ध बने रहे!
उसी समय, दिनचर्या से बचा गया था!

निष्कर्ष

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

PS यह समझा जाना चाहिए कि विभिन्न प्रकार के डेटा के लिए, "स्वच्छ" और "गंदे" डेटा प्रकार के साथ समानता पूरी तरह से उपयुक्त नहीं है।
उदाहरण के लिए, सूचियों के लिए
fmap = map
एक भिक्षु:

  a = do c <- cs d <- ds return (zet cd) 

वास्तव में है

 a = [zet cd | c <- cs, d <- ds] 

जो पहली नजर में हमेशा स्पष्ट नहीं होता है।