为什么是 MonadPlus 而不是 Monad + Monoid？

Question

我试图了解MonadPlus 背后的动机。如果已经有类型类Monad 和Monoid，为什么还需要？

当然，Monoid 的实例是具体类型，而Monad 的实例需要单个类型参数。 （请参阅Monoid vs MonadPlus 以获得有用的解释。）但是你不能重写任何类型约束

(MonadPlus m) => ...

作为Monad 和Monoid 的组合？

(Monad m, Monoid (m a)) => ...

以Control.Monad 中的guard 函数为例。它的实现是：

guard :: (MonadPlus m) => Bool -> m ()
guard True = return ()
guard False = mzero

我只能使用 Monad 和 Monoid 来实现它：

guard' :: (Monad m, Monoid (m ())) => Bool -> m ()
guard' True = return ()
guard' False = mempty

有人可以澄清MonadPlus 和Monad + Monoid 之间的真正区别吗？

Answer 1

但是你不能重写任何类型约束

(MonadPlus m) => ...

作为 Monad 和 Monoid 的组合？

没有。在您链接的问题的最佳答案中，已经对 MonadPlus 与 Monoid 的定律进行了很好的解释。但是，即使我们忽略类型类法则，也会存在差异。

Monoid (m a) => ... 意味着m a 必须是调用者选择的特定a 的一个幺半群，但MonadPlus m 意味着m a 必须是所有a 的一个幺半群。所以MonadPlus a更灵活，这种灵活性在四种情况下很有帮助：

1. 如果我们不想告诉调用者我们打算使用什么a。
   MonadPlus m => ... 而不是Monoid (m SecretType) => ...

2. 如果我们想使用多个不同的a。
   MonadPlus m => ... 而不是(Monoid (m Type1), Monoid (m Type2), ...) => ...

3. 如果我们想使用无限多个不同的a。
   MonadPlus m => ... 而不是不可能。

4. 如果我们不知道我们需要什么a。 MonadPlus m => ... 而不是不可能。

Answer 2

您的guard' 与您的Monoid m a 类型不匹配。

如果您的意思是Monoid (m a)，那么您需要定义mempty 是什么m ()。完成此操作后，您就定义了 MonadPlus。

换句话说，MonadPlus 定义了两个操作：mzero 和 mplus 满足两个规则：mzero 相对于 mplus 是中性的，mplus 是关联的。这满足Monoid 的定义，因此mzero 是mempty，mplus 是mappend。

不同之处在于MonadPlus m 是任何a 的幺半群m a，但Monoid m 只为m 定义了一个幺半群。您的 guard' 有效，因为您只需要 m 成为 Monoid 仅适用于 ()。但是MonadPlus 更强大，它声称m a 是任何a 的幺半群。

Answer 3

使用the QuantifiedConstraints language extension，您可以表示Monoid (m a) 实例必须在a 的所有选择中保持一致：

{-# LANGUAGE QuantifiedConstraints #-}

class (Monad m, forall a. Monoid (m a)) => MonadPlus m

mzero :: (MonadPlus m) => m a
mzero = mempty

mplus :: (MonadPlus m) => m a -> m a -> m a
mplus = mappend

Alternatively，我们可以为所有这样的 monoid-monads 实现“真正的”MonadPlus 类：

{-# LANGUAGE GeneralizedNewtypeDeriving, DerivingStrategies, QuantifiedConstraints #-}
{-# LANGUAGE UndecidableInstances #-}

import Control.Monad
import Control.Applicative

newtype MonoidMonad m a = MonoidMonad{ runMonoidMonad :: m a }
    deriving (Functor, Applicative, Monad)

instance (Applicative m, forall a. Monoid (m a)) => Alternative (MonoidMonad m) where
    empty = MonoidMonad mempty
    (MonoidMonad x) <|> (MonoidMonad y) = MonoidMonad (x <> y)

instance (Monad m, forall a. Monoid (m a)) => MonadPlus (MonoidMonad m)

请注意，根据您选择的m，这可能会或可能不会给您期望的MonadPlus；例如，MonoidMonad [] 与[] 完全相同；但是对于Maybe，Monoid 实例通过人为地赋予它一个标识元素来提升一些底层半群，而MonadPlus 实例是左偏选择；所以我们必须使用MonoidMonad First 而不是MonoidMonad Maybe 来获取正确的实例。

Answer 4

编辑：所以灯泡打开了，一切都咔哒一声就位。我完全误解了 Toxaris 的回答。现在我明白了，除了一些支持示例之外，我没有什么要补充的了，并且观察到 MonadPlus 类型类定义中似乎不需要 Alternative 和 Monad 约束。

monadPlusExample :: (MonadPlus m) => m Int
monadPlusExample = do
  x <- idM 7
  f <- idM (* 6)
  return $ f x
  where
    idM a = return a `mplus` mzero

-- a Monoid constraint for each lifted type
monoidExample :: (Monad m, Monoid (m Int), Monoid (m (Int -> Int))) => m Int
monoidExample = do
  x <- idM 7
  f <- idM (* 6)
  return $ f x
  where
    idM a = return a <> mempty

-- yes, QualifiedConstraints unifies the Monoid constraint quite nicely
monoidExample2 :: (Monad m, forall a. Monoid (m a)) => m Int
monoidExample2 = do
  x <- idM 7
  f <- idM (* 6)
  return $ f x
  where
    idM a = return a <> mempty

为了被调用，它们必须使用具体类型（例如monoidExample2 :: [Int]）