在单子变压器类型类中使用列表单子？

Question

我的目标是创建一个在 ReaderT WriterT 堆栈或 RWS 堆栈中使用 list monad 的函数。更一般地，如何在 MonadReader、MonadWriter 等 mtl 类型类中使用 list monad？

我为什么要这样做？这个问题是Beginning Haskell 中的一个练习。它要求我“使用 MonadReader 和 MonadWriter 包装基本列表 monad 的功能。要检查该功能是否通用，请使用两个不同的 monad 来 [测试] 请求的功能：ReaderT r (WriterT w []) a 和 RWST r w s m a”所以这本书暗示这是可能的。

我不知道如何“告诉”编译器使用 list monad。如果我使用 ask >>= lift 或 ask >>= lift . lift 我可以让 2 级堆栈 (RWST []) 或 3 级堆栈 (ReaderT WriterT []) 工作，但不能同时工作。

我问题的重点：

pathImplicitStack' start end | start == end = tell [end]
pathImplicitStack' start end =
  do  (s0, e0) <- ask >>= lift
      guard $ s0 == start
      tell [start]
      pathImplicitStack' e0 end

另外，我想知道如何键入函数。到目前为止，我最好的尝试看起来像 pathImplicitStack' :: (MonadReader [(Int, Int)] m, MonadWriter [Int] m, MonadPlus m) => Int -> Int -> m () 我知道这是不对的，可能缺少列表单子。另外，我认为 MonadPlus 在类型签名中可能有用，但我不太确定。

这一行：do (s0, e0) <- ask >>= lift 给我带来了麻烦。我尝试了 0、1 和 2 次升降机，但均未成功。我想ask 获取[(Int, Int)]，然后使用列表单子来处理(Int, Int)（并让列表单子为我尝试所有可能性）。

作为练习的一部分，我需要能够使用这两个函数（或非常相似的函数）调用pathImplicitStack'：

pathImplicitRW :: [(Int, Int)] -> Int -> Int -> [[Int]]
pathImplicitRW edges start end = execWriterT rdr
  where rdr = runReaderT (pathImplicitStack' start end) edges :: WriterT [Int] [] ()

pathImplicitRWS :: [(Int, Int)] -> Int -> Int -> [[Int]]
pathImplicitRWS edges start end = map snd exec
  where exec = execRWST (pathImplicitStack' start end) edges ()

这和我之前的问题有关：How do I use list monad inside of ReaderT?

整个文件方便测试：

{-# LANGUAGE FlexibleContexts #-}

module Foo where

import Control.Monad.Reader
import Control.Monad.Writer
import Control.Monad.RWS

graph1 :: [(Int, Int)]
graph1 = [(2013,501),(2013,1004),(501,2558),(1004,2558)]


pathImplicitRW :: [(Int, Int)] -> Int -> Int -> [[Int]]
pathImplicitRW edges start end = execWriterT rdr
  where rdr = runReaderT (pathImplicitStack' start end) edges :: WriterT [Int] [] ()

pathImplicitRWS :: [(Int, Int)] -> Int -> Int -> [[Int]]
pathImplicitRWS edges start end = map snd exec
  where exec = execRWST (pathImplicitStack' start end) edges ()

pathImplicitStack' :: (MonadReader [(Int, Int)] m, MonadWriter [Int] m, MonadPlus m) => Int -> Int -> [m ()]
pathImplicitStack' start end | start == end = tell [end]
pathImplicitStack' start end =
  do  (s0, e0) <- ask >>= lift
      guard $ s0 == start
      tell [start]
      pathImplicitStack' e0 end

编辑

根据我尝试过的 John L 的反馈

pathImplicitStack' :: (MonadReader [(Int, Int)] (t []), MonadWriter [Int] (t []), MonadPlus (t []), MonadTrans t) => Int -> Int -> t [] ()
pathImplicitStack' start end | start == end = tell [end]
pathImplicitStack' start end =
  do  (s0, e0) <- ask >>= lift
      guard $ s0 == start
      tell [start]
      pathImplicitStack' e0 end

但正如他所指出的，它只能与一个 monad 转换器一起使用来包装列表 monad，即 RSWT，并且不能与 ReaderT WriterT 一起使用。所以这不是我正在寻找的解决方案。

Answer 1

我认为这里的困难在于你混合了 monad 的层。看着

pathImplicitStack' :: (MonadReader [(Int, Int)] m, MonadWriter [Int] m, MonadPlus m) => Int -> Int -> [m ()]

此函数返回m () 计算列表，但是ask >>= lift（和您之前的问题）假定List 是您在其上堆叠额外转换器的基本单子。如果你想使用 List 作为基础 monad，你需要改变 pathImplicitStack' 的类型

pathImplicitStack' :: (MonadReader [(Int, Int)] (t []), MonadWriter [Int] (t []), MonadPlus (t [])) => Int -> Int -> t [] ()

但即使这样也不够通用，因为这只允许在列表顶部添加单个转换器。您可以使用类型运算符库将两个 monad 转换器组合成一个转换器，但这似乎有点复杂。

这是一种选择：使用 Identity 作为基础 monad，并在该 monad 堆栈之外执行列表操作。 （警告，所有代码未经测试，甚至可能无法编译）

pathImplicitStack' :: (MonadReader [(Int, Int)] m, MonadWriter [Int] m, MonadPlus m) => Int -> Int -> m ()
pathImplicitStack' start end | start == end = tell [end]
pathImplicitStack' start end =
  do  (s0, e0) <- ask >>= lift
      edges <- filter ((== start) . fst) <$> ask
      let m (s0,e0) = tell [s0] >> pathImplicitStack' e0 end
      mapM_ m edges

还有另一种选择。您可以使用ListT 或LogicT 作为外部转换器，让您使用此功能（或类似功能）：

pathImplicitStack'2 :: (MonadReader [(Int, Int)] m, MonadWriter [Int] m) => Int -> Int -> ListT m ()
pathImplicitStack'2 start end | start == end = tell [end]
pathImplicitStack'2 start end =
  do  (s0, e0) <- ask
      guard $ s0 == start
      tell [start]
      pathImplicitStack'2 e0 end
-- if you have MonadReader/MonadWriter instances for ListT in scope, I think this will
-- work.  But if they aren't available, you will need to use `lift ask` and 
-- `lift (tell ...)`

我几乎肯定会选择第一种方法。

Answer 2

因此，在问题要求范围内执行此操作的基本问题是，没有 MTL 库函数可以从可能是任意级别的列表 monad 中提升。但是，您可以“欺骗”一点：组合 Monad 的 MonadPlus 实例 继承自底层列表 monad，无论深度如何，您都可以使用它来生成所需的操作：

  do  (s0, e0) <- ask >>= msum . map return

然后类型签名也有错误，需要改成：

pathImplicitStack' :: (MonadReader [(Int, Int)] m, MonadWriter [Int] m, MonadPlus m) => Int -> Int -> m ()

编辑：实际上再三考虑这实际上并不是作弊。它只是使用MonadPlus API 来链接替代操作，而不是直接使用底层列表 monad。