8

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

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

我不知道如何“告诉”编译器使用列表单子。如果我使用ask >>= liftorask >>= 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 次升降机，但均未成功。我想askfor a[(Int, Int)]然后使用 list monad 来处理 a (Int, Int)（并让 list monad 为我尝试所有可能性）。

作为练习的一部分，我需要能够调用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 ()

这与我之前的问题有关：如何在 ReaderT 中使用 list monad？

整个文件便于测试：

{-# 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 一起使用。所以这不是我正在寻找的解决方案。

4

2 回答 2

5

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

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

那么类型签名也有错误，需要改成：

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

编辑：实际上在第二个想法这实际上并不是作弊。它只是使用MonadPlusAPI 链接替代操作，而不是直接使用底层列表 monad。

于 2014-06-13T13:04:30.010 回答
2

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

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

这个函数返回一个m ()计算列表，但是ask >>= lift（和你之前的问题）假设这List是你堆叠额外转换器的基础 monad。如果您想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

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

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 ...)`

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

于 2014-06-13T00:50:25.980 回答