为嵌套的单子类型实现单子实例

Question

作为 Haskell 自学练习的一部分，我正在尝试为我的类型派生一个 Monad 实例。类型定义为：

newtype ParsePackUnpack f a = ParsePackUnpack
  {
    unparse:: State PackUnpackState (Ap f a)
  }

其中Ap f a 来自Data.Monoid。对于我的类型，我想说解析是一个有状态的操作，结果是任何monoid。

到目前为止，我已经通过提升成功实现了这个 3 级深度类型的 Functor 和 Applicative 实例：

instance Functor f => Functor (ParsePackUnpack f) where
  fmap f ma =
    let f' = fmap f     -- lift (a -> b) to (Ap f a -> Ap f b)
     in ParsePackUnpack $ f' <$> (unparse ma)

instance Applicative f => Applicative (ParsePackUnpack f) where
  pure = ParsePackUnpack . pure . pure

  f <*> ma =
    let f' = liftA2 (<*>) . unparse $ f       -- lift Ap f (a -> b) -> Ap f a -> Ap f b to State s (Ap f a) -> State s (Ap f b)
     in ParsePackUnpack $ f' (unparse ma)     -- Apply to State s (Ap f a)

但我无法为我的类型正确派生 Monad 实例。经过一番打高尔夫球后，这是我的最新尝试：

instance Monad f => Monad (ParsePackUnpack f) where
  return = ParsePackUnpack . return . return

  ma >>= f = ParsePackUnpack . state $ \st ->
    let (a, s) = runState (unparse ma) st
        res = a >>= fst . flip runState s . unparse . f -- fst ignores state from the result
    in (res, s)

我认为这是不正确的，因为我忽略了 res 操作中的状态。

为我的类型实现>>= 操作的正确方法是什么？由于这是一个学习练习，我试图避免使用 Monad 变压器。如果 Monad 变压器是要走的路，你能解释一下为什么会这样吗？

Answer 1

Monad 的组合不如应用程序好。虽然f (g a) 在f 和g 存在时是一个应用程序（因此您可以编写应用程序实例），但当f 和g 是单子时，它通常不是单子。这就是为什么我们需要单子转换器而不是应用转换器。

这是一个相关的练习。忘记使用库中的State，让我们手动使用它的表示。 State s (IO a) 展开为 s -> (IO a, s)。要实现绑定，您将获得

f :: s -> (IO a, s)
g :: a -> s -> (IO b, s)

您能想出如何通过“有状态”传递s 来将第一个喂给第二个吗？

bound :: s -> (IO b, s)
bound s0 = ??

试一试。 （剧透）在你确信这是不可能的之后，想想是什么让它不可能，以及你需要如何修改类型以使其成为可能。然后使用该模式定义一个“StateIO s”monad。