为什么电梯的返回值不被限制为单子？

Question

为什么MonadTrans不被定义为

class MonadTrans t where
    lift :: (Monad m, Monad (t m)) => m a -> t m a
--                    ^^^^^^^^^^^

而不是当前

class MonadTrans t where
    lift :: Monad m => m a -> t m a

这是 Haskell 98（与 Why aren't monad transformers constrained to yield monads? 中的建议不同）并确保结果始终是 monad。允许 monad 转换器产生不是 monad 的东西是有原因的吗？

Answer 1

bheklilr 的回答让我想到了一个例子，其中 monad 转换器产生了不是 monad 的东西。 ZipList 是非 monad 的一个著名例子。我们可以创建一个变体，在每个级别运行一个单子动作：

import Control.Applicative
import Control.Arrow ((***))
import Control.Monad
import Control.Monad.Trans

-- | A list where each step is produced by a monadic action.
data ListT m a = Nil | Cons (m (a, ListT m a))

这实际上是一个 monad 流。而且可以很方便的做成Functor和Applicative

instance Monad m => Functor (ListT m) where
    fmap f Nil      = Nil
    fmap f (Cons k) = Cons $ (f *** fmap f) `liftM` k
instance Monad m => Applicative (ListT m) where
    pure x = Cons $ return (x, pure x)
    Cons mf <*> Cons mx = Cons $ do
        (f, fs) <- mf
        (x, xs) <- mx
        return (f x, fs <*> xs)
    _       <*> _       = Nil

但显然不是单子。所以我们有一个 MonadTrans 实例，它可以将 monad 转换为仅是 Applicative 的东西。

instance MonadTrans ListT where
    lift mx = Cons $ (\x -> (x, lift mx)) `liftM` mx

（整件事让我意识到 conduit-extra 中的实验性 ZipSink 也是一个很好的例子。）

---

但是，这又提出了另一个问题：如果我们想要这样的变形金刚，它们应该遵守哪些法律？ MonadTrans 的法律定义为

lift . return = return
lift (m >>= f) = lift m >>= (lift . f)

所以在我们的例子中，我们希望得到类似的东西

lift (f `liftM` x)  = fmap f (lift x)

lift . return       = pure
lift (m `ap` f)     = lift m <*> lift f

Answer 2

我的猜测是MonadTrans 将Monad 转换为其他东西，而不是将Monad 转换为Monad。它更通用，因为您可能会编写一些转换 Monad 的东西，并且您可以定义 lift，但您不能定义 >>= 和 return。由于大多数（如果不是全部）MonadTrans 实例最终都是Monads，因此编译器仍然可以很好地处理它，因此它并没有真正出现问题。

Answer 3

我不同意其他两个答案，说结果应该是一个单子。原因是，否则lift 不应该遵守任何明智的法律。

lift 应该是一个单子态射，这意味着它应该遵守以下两个定律：

lift (return x) = return x

lift (m >>= f) = lift m >>= \r -> lift (f r)

当您意识到它们是两个 Kleisli 类别之间的函子定律时，这些定律会更有意义：

-- i.e. "fmap id = id"
(lift .) return = return

-- i.e. "fmap (f . g) = fmap f . fmap g"
(lift .) (f >=> g) = (lift .) f >=> (lift .) g

但是，如果您不将输出限制为 monad，那么这些定律将不再有效，并且您无法验证您是否正确实施了 lift。

我怀疑真正的原因是制作 Haskell98 类