别害怕！阅读器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。
读者monad也可用于执行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和其他功能语言都基于lambda演算。Lambda演算的语法看起来像
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 [])
就是这样。Lambda演算的全功能解释器。
考虑这个问题的另一种方法是问：它是如何实现的？答案是读者单子实际上是所有单子中最简单，最优雅的一种。
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
现在，获取单子：
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只是一个函数。为什么要有读者？好问题。实际上，您不需要它！
instance Functor ((->) env) where
fmap = (.)
instance Monad ((->) env) where
return = const
f >>= g = \x -> g (f x) x
这些甚至更简单。更重要的是，ask仅仅是id和local只是函数组合与功能的顺序切换！