为什么要把Reader的构造函数参数定义为函数呢？

在学习Reader Monad时，我发现它的定义是：

newtype Reader r a = Reader { runReader :: r -> a }

instance Monad (Reader r) where
  return a = Reader $ \_ -> a
  m >>= k  = Reader $ \r -> runReader (k (runReader m r)) r

我想知道为什么使用函数作为构造函数参数而不是其他东西（例如元组）：

newtype Reader r a = Reader { runReader :: (r, a) }

instance Monad (Reader r) where
  -- Here I cannot get r when defining return function, 
  -- so does that's the reason that must using a function whose input is an "r"?
  return a = Reader (r_unknown, a) 
  m >>= k = Reader (fst $ runReader m) (f (snd $ runReader m))

根据Reader的定义，我们需要一个可以用来生成“值”的“环境”。我认为 Reader 类型应该包含“环境”和“值”的信息，因此该元组看起来很完美。

你在问题中没有提到它，但我猜你特别想到使用一对来定义Reader因为将其视为提供固定环境的一种方式也是有意义的。假设我们有一个较早的结果Reader monad:

return 2 :: Reader Integer Integer

我们可以使用这个结果对固定环境（以及Monad方法保证它在整个链条中保持固定(>>=)):

GHCi> runReader (return 2 >>= \x -> Reader (\r -> x + r)) 3
5

（如果你替换的定义return, (>>=) and runReader将上面的表达式简化并简化，您将确切地看到它如何简化为2 + 3.)

现在，让我们按照您的建议并定义：

newtype Env r a = Env { runEnv :: (r, a) }

如果我们有一个类型的环境r和类型的先前结果a，我们可以做一个Env r a从他们当中……

Env (3, 2) :: Env Integer Integer

...我们还可以从中得到一个新的结果：

GHCi> (\(r, x) -> x + r) . runEnv $ Env (3, 2)
5

那么问题是我们是否可以通过Monad界面。答案是不。在那里时is a Monad例如，对于成对的例子，它做了一些完全不同的事情：

newtype Writer r a = Writer { Writer :: (r, a) }

instance Monoid r => Monad (Writer r) where
    return x = (mempty, x)
    m >>= f = Writer 
        . (\(r, x) -> (\(s, y) -> (mappend r s, y)) $ f x)
        $ runWriter m

The Monoid需要约束，以便我们可以使用mempty（这解决了您注意到必须创建一个r_unknown不知从何而来）和mappend（这使得可以以不违反单子定律的方式组合该对的第一个元素）。这Monad然而，实例所做的事情与Reader有一个。该对的第一个元素不是固定的（它可能会发生变化，因为我们mappend其他生成的值）并且我们不使用它来计算该对的第二个元素（在上面的定义中，y不依赖于r nor on s). Writer是一个记录器；这r这里的值是输出，而不是输入。

然而，有一种方法可以证明你的直觉是正确的：我们不能使用一对来创建一个像读者一样的单子，但是我们可以制作一个像读者一样的单子co单子。非常宽松地说，Comonad https://hackage.haskell.org/package/comonad-5/docs/Control-Comonad.html#t:Comonad当你转动时你会得到什么Monad界面颠倒：

-- This is slightly different than what you'll find in Control.Comonad,
-- but it boils down to the same thing.
class Comonad w where
    extract :: w a -> a                 -- compare with return
    (=>>) :: w a -> (w a -> b) -> w b   -- compare with (>>=)

我们可以给Env我们已经放弃了Comonad实例：

newtype Env r a = Env { runEnv :: (r, a) }

instance Comonad (Env r) where
    extract (Env (_, x)) = x
    w@(Env (r, _)) =>> f = Env (r, f w)

这使我们能够写出2 + 3从一开始的例子(=>>):

GHCi> runEnv $ Env (3, 2) =>> ((\(r, x) -> x + r) . runEnv) 
(3,5)

了解其为何有效的一种方法是注意到a -> Reader r b功能（即你给予什么Reader's (>>=)）本质上是一样的Env r a -> b一个（即你给予的Env's (=>>)):

a -> Reader r b
a -> (r -> b)     -- Unwrap the Reader result
r -> (a -> b)     -- Flip the function
(r, a) -> b       -- Uncurry the function
Env r a -> b      -- Wrap the argument pair

作为这一点的进一步证据，这里有一个将一个函数更改为另一个函数的函数：

GHCi> :t \f -> \w -> (\(r, x) -> runReader (f x) r) $ runEnv w
\f -> \w -> (\(r, x) -> runReader (f x) r) $ runEnv w
  :: (t -> Reader r a) -> Env r t -> a
GHCi> -- Or, equivalently:
GHCi> :t \f -> uncurry (flip (runReader . f)) . runEnv
\f -> uncurry (flip (runReader . f)) . runEnv
  :: (a -> Reader r c) -> Env r a -> c

总结一下，这是一个稍微长一点的例子，Reader and Env并排版本：

GHCi> :{
GHCi| flip runReader 3 $
GHCi|     return 2 >>= \x ->
GHCi|     Reader (\r -> x ^ r) >>= \y ->
GHCi|     Reader (\r -> y - r)
GHCi| :}
5
GHCi> :{
GHCi| extract $
GHCi|     Env (3, 2) =>> (\w ->
GHCi|     (\(r, x) -> x ^ r) $ runEnv w) =>> (\z ->
GHCi|     (\(r, x) -> x - r) $ runEnv z)
GHCi| :}
5