Haskell 中映射 MonadTrans 的函数？

Question

我最近决定开始使用 monad 转换而不是堆叠我的 monad，因为这似乎是正确的做法。无论如何，我之前并没有真正堆叠很多单子。我得到（我认为）它背后的想法和 lift 函数，据我所知，它充当了转换的一种 return （将一些来自底层 monad 的东西放入转换后的 monad）。

到目前为止一切都很好，但我没有看到任何类似于 fmap 用于单子转换的函数。让我给你举个例子。假设我有一个自定义 monad，m，并且我在其上使用了 StateT 转换，因此使用类型 StateT s m a 而不是 m (State s a)。

现在，碰巧在我的 monad m 中，我有一个函数可以转换 monadic 元素（实际上它是 monad 的构造函数之一，如果您需要我可以提供的详细信息），同时保留一些感知潜在价值：myFunc :: m a -> m a。

所以我正在构建一个递归函数recFunc :: State s a -> [t] -> m (State s a)，看起来类似于这样：

recFunc :: State s a -> [t] -> m (State s a)
recFunc x [] = return x
recFunc x (t:ts) = myFunc (recFunc x ts)

但是如果我尝试使用 monad 转换来复制它，我会遇到问题，因为我找不到将 myFunc 插入到混合中的方法。将输入写为State s a 还是StateT s Identity a 都没有关系（代数上哪个更精确？）

recFuncT :: StateT s Identity a -> [t] -> StateT s m a
recFuncT x [] = ???
recFuncT x (t:ts) = ????? where rec = recFuncT x ts

所以我正在寻找类似（发明，如果可能的话我不知道如何实现）以下功能：

transmap :: (MonadTrans t, Monad m) => (forall b. m b -> m b) -> t m a -> t m a
transmap = ???

transreturn :: (MonadTrans t, Monad m) => m (t Identity a) -> t m a
transreturn = ???

我觉得我应该能够使用 lift 定义这些，但老实说，我不知道如何。

如果我有它们，那么我可以这样做：

recFuncT :: StateT s Identity a -> [t] -> StateT s m a
recFuncT x [] = transreturn (return x)
recFuncT x (t:ts) = transmap myFunc (recFuncT x ts)

也许我真正想要的是更基本的东西。我希望t m a 和m (t Identity a) 之间假定的同构是明确的，所以我正在寻找函数：

fromTrans :: t m a -> m (t Identity a)
toTrans :: m (t Identity a) -> t m a

据我了解 monad 转换器，这些函数应该始终存在并且相当简单，对吧？

有了这些，我显然可以实现transmap 和transreturn：

transmap :: (MonadTrans t, Monad m) => (forall b. m b -> m b) -> t m a -> t m a
transmap f x = toTrans (f (fromTrans x))

transreturn :: (MonadTrans t, Monad m) => m (t Identity a) -> t m a
transreturn = toTrans

我确信我忽略了一些明显的东西。请为我指出来。

谢谢。

Answer 1

根据 cmets 中的讨论，听起来您真正想要的是自定义 monad 的 monad 转换器，然后将其应用于基本 monad State。换句话说，如果您的自定义 monad “几乎”是一个列表：

newtype Listish a = Listish [a]

它的转换器版本将具有类型：

newtype ListishT m a = ListishT [m a]

所以你最终的 monad 转换器堆栈将是：

type M s = ListishT (State s)

与你的 monad 堆栈同构

[State s a]  AKA  Listish (State s a)

不过，请确保不要过度概括从底层 monad 创建转换器的模式。而一些单子的变形金刚：

newtype List a = List [a]
newtype Reader r a = Reader (r -> a)

通过将“a”替换为“m a”来合理推导出：

newtype ListT m a = ListT [m a]
newtype ReaderT r m a = ReaderT (r -> m a)

其他类型的变压器的派生方式不同。例如：

newtype State s a = State (s -> (a, s))
newtype Writer w a = Writer (a, w)

给：

newtype StateT s a = StateT (s -> m (a, s))
-- **NOT** StateT (s -> (m a, s))
newtype WriterT s a = WriterT (m (a, w))
-- **NOT** WriterT (m a, w)

特别是IO 没有单子转换器，因为简单的替换

newtype BadIOT m a = BadIOT (IO (m a))

正如你所指出的那样，很愚蠢。

Answer 2

您正在寻找的一个概念似乎可以在mmorph 包中找到：

class MFunctor t where
  -- The argument is generally required to be a monad morphism,
  -- but some instances will work sensibly when it's not.
  hoist :: Monad m => (forall x. m x -> n x) -> t m a -> t n a

这比你的版本更通用一点，因为它允许替换底层的 monad。

Answer 3

编辑：以下所有内容都毫无意义。我留下删除线。下面的答案很好。

为了记录，我的最终解决方案既不是使用也不是实现 monad 转换器，而是简单地实现以下功能：（我的自定义 monad 称为EnumProc）：

(..>>=) :: Monad m => EnumProc (m a) -> (a -> m b) -> EnumProc (m b)
en ..>>= f = en <$> (>>= f)
infixl 7 ..>>=

这让我可以在我的 monad 内部处理 monadic 计算，同时保持外部 monad 结构。当fmap 足够时，我自己都感到惊讶。

然后我使用EnumProc (State s a) 作为整个类型。

Answer 4

过了一会儿，我终于想出了我从一开始就在寻找的东西。我可以完全按照我想要的方式使用StateT，它具有我认为的语义，但是我没有很好地解释它（并且在我写的内容中加入了错误）。

回到我原来的帖子，我不需要State 作为输入，State/StateT monad 已经在 monadic 元素中包含了输入。所以我需要的是一个函数recFuncT :: [t] -> StateT s m a，它的行为等同于以下非变压器：

recFunc :: a -> [t] -> m (State s a)
recFunc x [] = return (return x)
recFunc x (t:ts) = myFunc (recFunc x ts)

可以直接实现，使用构造函数StateT和runStateT。这里是：

recFuncT :: a -> [t] -> StateT m s a
recFuncT x [] = return x
recFuncT x (t:ts) = StateT (\s -> myFunc (runStateT (recFuncT x ts) s))

此外，transmap 的功能也可以实现一般的，至少对于StateT：

transmap :: Monad m => (forall b. m b -> m b) -> StateT s m a -> StateT s m a
transmap f st = StateT (\s -> f (runStateT st s)

然后我们可以用它很好地写recFuncT：

recFuncT :: a -> [t] -> StateT m s a
recFuncT x [] = return x
recFuncT x (t:ts) = transmap myFunc (recFuncT x ts)

我意识到这与我最初包含的代码并不真正匹配，但它确实符合我试图诉诸的总体原则，即StateT 转换器就像向我的 monad m 添加状态一样，因此可以在m (State s a) 级别完成的任何事情都可以在StateT s m a 级别完成。