ไม่ต้องกลัว! ตัวอ่าน monad นั้นไม่ซับซ้อนและมียูทิลิตี้ที่ใช้งานง่ายอย่างแท้จริง
มีสองวิธีในการเข้าหาโมนาด: เราถามได้
- Monad ทำอะไร? มีระบบปฏิบัติการอะไรบ้าง? มันดีสำหรับอะไร?
- monad ใช้งานอย่างไร? มันเกิดขึ้นจากไหน?
จากแนวทางแรกผู้อ่าน monad เป็นนามธรรมบางประเภท
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
แล้วเราจะใช้สิ่งนี้อย่างไร? ผู้อ่าน monad นั้นดีสำหรับการส่งผ่านข้อมูลการกำหนดค่า (โดยนัย) ผ่านการคำนวณ
เมื่อใดก็ตามที่คุณมี "ค่าคงที่" ในการคำนวณที่คุณต้องการในหลาย ๆ จุด แต่จริงๆแล้วคุณต้องการที่จะสามารถทำการคำนวณเดียวกันกับค่าที่แตกต่างกันคุณควรใช้ตัวอ่าน monad
monads อ่านยังจะใช้ในการทำในสิ่งที่คน OO เรียกฉีดพึ่งพา ตัวอย่างเช่นอัลกอริทึมNegamaxถูกใช้บ่อย (ในรูปแบบที่ได้รับการปรับให้เหมาะสมที่สุด) เพื่อคำนวณมูลค่าของตำแหน่งในเกมที่มีผู้เล่นสองคน แม้ว่าอัลกอริทึมจะไม่สนใจว่าคุณกำลังเล่นเกมอะไรอยู่ยกเว้นว่าคุณต้องสามารถกำหนดตำแหน่ง "ถัดไป" ในเกมได้และคุณต้องสามารถบอกได้ว่าตำแหน่งปัจจุบันเป็นตำแหน่งแห่งชัยชนะหรือไม่
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
เพื่อรับราคาสปอต จากนั้นคุณสามารถเรียกพจนานุกรมนี้ในรหัสของคุณได้ .... แต่เดี๋ยวก่อน! ไม่ได้ผล! พจนานุกรมสกุลเงินนั้นไม่เปลี่ยนรูปและต้องเหมือนกันไม่เพียง แต่ตลอดอายุการใช้งานของโปรแกรมของคุณเท่านั้น แต่ยังรวมถึงเวลาที่รวบรวมด้วย ! แล้วคุณจะทำอย่างไร? ทางเลือกหนึ่งคือใช้ Reader monad:
computePrice :: Reader CurrencyDict Dollars
computePrice
= do currencyDict <- ask
--insert computation here
บางทีการใช้งานที่คลาสสิกที่สุดคือการใช้ล่าม แต่ก่อนที่เราจะดูนั้นเราต้องแนะนำฟังก์ชันอื่น
local :: (env -> env) -> Reader env a -> Reader env a
เอาล่ะเพื่อ Haskell และภาษาอื่น ๆ ที่ทำงานอยู่บนพื้นฐานของแคลคูลัสแลมบ์ดา แลมบ์ดาแคลคูลัสมีไวยากรณ์ที่ดูเหมือน
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 [])
และนั่นก็คือ ล่ามที่ทำงานได้อย่างสมบูรณ์สำหรับแคลคูลัสแลมบ์ดา
อีกวิธีหนึ่งในการคิดเกี่ยวกับเรื่องนี้คือการถามว่ามีการดำเนินการอย่างไร คำตอบก็คือผู้อ่าน monad เป็นหนึ่งในตัวละครที่เรียบง่ายและสง่างามที่สุดในบรรดา monad ทั้งหมด
newtype Reader env a = Reader {runReader :: env -> a}
Reader เป็นเพียงชื่อแฟนซีสำหรับฟังก์ชัน! เราได้กำหนดไว้แล้วแล้วrunReaderส่วนอื่น ๆ ของ API ล่ะ? ทุกคน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)
โอเคดังนั้นผู้อ่าน monad เป็นเพียงหน้าที่ ทำไมมี Reader เลย? คำถามที่ดี. ที่จริงคุณไม่ต้องการมัน!
instance Functor ((->) env) where
fmap = (.)
instance Monad ((->) env) where
return = const
f >>= g = \x -> g (f x) x
สิ่งเหล่านี้ง่ายกว่าด้วยซ้ำ มีอะไรมากกว่าที่askเป็นเพียงidและlocalเป็นเพียงองค์ประกอบของฟังก์ชั่นคำสั่งของฟังก์ชั่นเปลี่ยน!