ভয় পাবেন না! পাঠক মোনাড আসলে এত জটিল নয় এবং আসল ব্যবহারযোগ্য ইউটিলিটি রয়েছে।
একটি মনাদ কাছে যাওয়ার দুটি উপায় আছে: আমরা জিজ্ঞাসা করতে পারি
- একসংখ্যা কী না ? এটি কোন অপারেশন দিয়ে সজ্জিত? এটা কি জন্য ভাল?
- মোনাড কীভাবে প্রয়োগ করা হয়? কোথা থেকে এটি উত্থিত হয়?
প্রথম পদ্ধতির থেকে, পাঠক মনাদ কিছু বিমূর্ত প্রকারের
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
এটি তখন যে কোনও সীমাবদ্ধ, নির্জনবাদী, দুটি প্লেয়ার গেম নিয়ে কাজ করবে।
সত্যিকারের নির্ভরতা ইনজেকশন নয় এমন জিনিসগুলির জন্যও এই প্যাটার্নটি কার্যকর। মনে করুন যে আপনি অর্থায়নে কাজ করেন, আপনি কোনও সম্পত্তির মূল্য নির্ধারণের জন্য কিছু জটিল যুক্তি ডিজাইন করতে পারেন (একটি ডেরাইভেটিভ বলে), যা সব ভাল এবং ভাল এবং আপনি কোনও দুর্গন্ধযুক্ত মনড ছাড়াই করতে পারেন। তবে, আপনি একাধিক মুদ্রার সাথে ডিল করতে আপনার প্রোগ্রামটি পরিবর্তন করেছেন ify আপনাকে ফ্লাইতে মুদ্রার মধ্যে রূপান্তর করতে সক্ষম হতে হবে। আপনার প্রথম প্রচেষ্টাটি শীর্ষ স্তরের ফাংশনটি সংজ্ঞায়িত করা
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 [])
এবং এটি হয়। ল্যাম্বডা ক্যালকুলাসের জন্য সম্পূর্ণ কার্যকারী দোভাষী inter
এ সম্পর্কে চিন্তা করার অন্য উপায়টি জিজ্ঞাসা করা: এটি কীভাবে বাস্তবায়ন করা হয়? উত্তরটি হ'ল পাঠক মোনাড প্রকৃতপক্ষে সমস্ত মনাদাদের মধ্যে অন্যতম সরল এবং মার্জিত।
newtype Reader env a = Reader {runReader :: env -> a}
পাঠক কার্যকারিতা জন্য একটি অভিনব নাম! আমরা ইতিমধ্যে সংজ্ঞায়িত করেছি runReaderতাই এপিআই এর অন্যান্য অংশগুলির কী হবে? ঠিক আছে, প্রত্যেকটি Monadএকটি Functor:
instance Functor (Reader env) where
fmap f (Reader g) = Reader $ f . g
এখন, একটি monad পেতে:
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সক্রিয় ফাংশন ক্রম সঙ্গে ফাংশন রচনা!