डरो मत! पाठक मोनड वास्तव में इतना जटिल नहीं है, और वास्तविक उपयोग में आसान उपयोगिता है।
एक साधु से संपर्क करने के दो तरीके हैं: हम पूछ सकते हैं
- सन्यासी क्या करता है ? यह किस ऑपरेशन से सुसज्जित है? ये किस काम के लिए अच्छा है?
- मोनाड को कैसे लागू किया जाता है? यह कहाँ से उत्पन्न होता है?
पहले दृष्टिकोण से, पाठक मोनड कुछ सार प्रकार है
data Reader env a
ऐसा है कि
-- Reader is a monad
instance Monad (Reader env)
-- and we have a function to get its environment
ask :: Reader env env
-- finally, we can run a Reader
runReader :: Reader env a -> env -> a
तो हम इसका उपयोग कैसे करते हैं? खैर, पाठक मोनड एक संगणना के माध्यम से (अंतर्निहित) कॉन्फ़िगरेशन जानकारी पास करने के लिए अच्छा है।
किसी भी समय आपके पास एक संगणना में "निरंतर" होता है जिसकी आपको विभिन्न बिंदुओं पर आवश्यकता होती है, लेकिन वास्तव में आप विभिन्न मूल्यों के साथ एक ही संगणना करने में सक्षम होना चाहते हैं, तो आपको एक पाठक मोनाद का उपयोग करना चाहिए।
रीडर मोनैड्स का उपयोग करने के लिए भी किया जाता है जो ओओ लोग निर्भरता इंजेक्शन कहते हैं । उदाहरण के लिए, दो खिलाड़ियों के खेल में एक स्थिति के मूल्य की गणना करने के लिए नेग्मैक्स एल्गोरिथ्म का अक्सर (अत्यधिक अनुकूलित रूपों में) उपयोग किया जाता है। एल्गोरिथ्म हालांकि खुद को परवाह नहीं करता है कि आप कौन सा खेल खेल रहे हैं, सिवाय इसके कि आपको यह निर्धारित करने में सक्षम होना चाहिए कि खेल में "अगले" स्थान क्या हैं, और आपको यह बताने में सक्षम होने की आवश्यकता है कि क्या वर्तमान स्थिति जीत की स्थिति है।
import Control.Monad.Reader
data GameState = NotOver | FirstPlayerWin | SecondPlayerWin | Tie
data Game position
= Game {
getNext :: position -> [position],
getState :: position -> GameState
}
getNext' :: position -> Reader (Game position) [position]
getNext' position
= do game <- ask
return $ getNext game position
getState' :: position -> Reader (Game position) GameState
getState' position
= do game <- ask
return $ getState game position
negamax :: Double -> position -> Reader (Game position) Double
negamax color position
= do state <- getState' position
case state of
FirstPlayerWin -> return color
SecondPlayerWin -> return $ negate color
Tie -> return 0
NotOver -> do possible <- getNext' position
values <- mapM ((liftM negate) . negamax (negate color)) possible
return $ maximum values
यह तब किसी भी परिमित, नियतात्मक, दो खिलाड़ी खेल के साथ काम करेगा।
यह पैटर्न उन चीजों के लिए भी उपयोगी है जो वास्तव में निर्भरता इंजेक्शन नहीं हैं। मान लीजिए कि आप वित्त में काम करते हैं, तो आप किसी परिसंपत्ति (एक व्युत्पन्न कहना) के मूल्य निर्धारण के लिए कुछ जटिल तर्क तैयार कर सकते हैं, जो सभी अच्छी तरह से और अच्छा है और आप बिना किसी बदबूदार मठों के कर सकते हैं। लेकिन फिर, आप कई मुद्राओं से निपटने के लिए अपने कार्यक्रम को संशोधित करते हैं। आपको मक्खी पर मुद्राओं के बीच परिवर्तित करने में सक्षम होना चाहिए। आपका पहला प्रयास शीर्ष स्तर के कार्य को परिभाषित करना है
type CurrencyDict = Map CurrencyName Dollars
currencyDict :: CurrencyDict
हाजिर भाव पाने के लिए। फिर आप इस शब्दकोष को अपने कोड में कॉल कर सकते हैं .... लेकिन रुकिए! यह काम नहीं करेगा! मुद्रा शब्दकोश अपरिवर्तनीय है और इसलिए इसे न केवल आपके कार्यक्रम के जीवन के लिए समान होना चाहिए, लेकिन समय से यह संकलित हो जाता है ! तो तुम क्या करते हो? खैर, एक विकल्प यह होगा कि पाठक मोन का उपयोग करें:
computePrice :: Reader CurrencyDict Dollars
computePrice
= do currencyDict <- ask
--insert computation here
व्याख्याताओं को लागू करने में शायद सबसे क्लासिक उपयोग-मामला है। लेकिन, इससे पहले कि हम देखें, हमें एक और फ़ंक्शन शुरू करने की आवश्यकता है
local :: (env -> env) -> Reader env a -> Reader env a
ठीक है, इसलिए हास्केल और अन्य कार्यात्मक भाषाएं लैम्ब्डा कैलकुलस पर आधारित हैं । लैम्ब्डा कैलकुलस में एक सिंटैक्स होता है जो दिखता है
data Term = Apply Term Term | Lambda String Term | Var Term deriving (Show)
और हम इस भाषा के लिए एक मूल्यांकनकर्ता लिखना चाहते हैं। ऐसा करने के लिए, हमें एक पर्यावरण पर नज़र रखने की आवश्यकता होगी, जो शर्तों से जुड़ी बाइंडिंग की एक सूची है (वास्तव में यह बंद हो जाएगा क्योंकि हम स्थैतिक स्कूपिंग करना चाहते हैं)।
newtype Env = Env ([(String, Closure)])
type Closure = (Term, Env)
जब हम कर रहे हैं, हम एक मूल्य (या एक त्रुटि) बाहर निकलना चाहिए:
data Value = Lam String Closure | Failure String
तो, दुभाषिया लिखें:
interp' :: Term -> Reader Env Value
--when we have a lambda term, we can just return it
interp' (Lambda nv t)
= do env <- ask
return $ Lam nv (t, env)
--when we run into a value, we look it up in the environment
interp' (Var v)
= do (Env env) <- ask
case lookup (show v) env of
-- if it is not in the environment we have a problem
Nothing -> return . Failure $ "unbound variable: " ++ (show v)
-- if it is in the environment, then we should interpret it
Just (term, env) -> local (const env) $ interp' term
--the complicated case is an application
interp' (Apply t1 t2)
= do v1 <- interp' t1
case v1 of
Failure s -> return (Failure s)
Lam nv clos -> local (\(Env ls) -> Env ((nv, clos) : ls)) $ interp' t2
--I guess not that complicated!
अंत में, हम एक तुच्छ वातावरण पारित करके इसका उपयोग कर सकते हैं:
interp :: Term -> Value
interp term = runReader (interp' term) (Env [])
और वह यह है। लैम्ब्डा कैलकुलस के लिए एक पूरी तरह कार्यात्मक दुभाषिया।
इसके बारे में सोचने का दूसरा तरीका यह है कि यह कैसे लागू किया जाए? इसका उत्तर यह है कि पाठक मोनाड वास्तव में सभी साधुओं में से सबसे सरल और सुरुचिपूर्ण है।
newtype Reader env a = Reader {runReader :: env -> a}
पाठक कार्यों के लिए सिर्फ एक फैंसी नाम है! हमने पहले ही परिभाषित runReaderकर दिया है कि एपीआई के अन्य भागों के बारे में क्या है? खैर, हर Monadभी एक है Functor:
instance Functor (Reader env) where
fmap f (Reader g) = Reader $ f . g
अब, एक सनद पाने के लिए:
instance Monad (Reader env) where
return x = Reader (\_ -> x)
(Reader f) >>= g = Reader $ \x -> runReader (g (f x)) x
जो इतना डरावना नहीं है। askवास्तव में सरल है:
ask = Reader $ \x -> x
जबकि localइतना बुरा नहीं है:
local f (Reader g) = Reader $ \x -> runReader g (f x)
ठीक है, इसलिए पाठक मोनाड सिर्फ एक फ़ंक्शन है। पाठक आखिर क्यों हैं? अच्छा प्रश्न। वास्तव में, आपको इसकी आवश्यकता नहीं है!
instance Functor ((->) env) where
fmap = (.)
instance Monad ((->) env) where
return = const
f >>= g = \x -> g (f x) x
ये और भी सरल हैं। क्या अधिक है, askबस है idऔर localबस फंक्शंस के क्रम के साथ फ़ंक्शन रचना है!