列表理解保护等效于 filterM

Question

列表推导与map 和filter 有重叠的功能。 filterM 迎合了谓词返回 Bool 包裹在 monad 中的情况（准确地说，是 Applicative）。 mapM 对结果封装在 Applicative 中的映射函数做了类似的事情。

如果您想通过列表理解来重现 mapM 的行为，sequence 可以提供帮助。但是filterM 怎么能被列表理解替换呢？换句话说，在上下文中返回 Bool 的谓词如何在列表推导中用作保护？

以下是探索 2x2x2 空间的简单示例（filter/map, function/c omprehension, plain/monadic) 以上的观察，只是我不知道怎么写fcm。如何修复fcm 使其与ffm 具有相同的值？

import Control.Monad (filterM)

predicate = (>3)
convert = (*10)
predicateM = Just . predicate -- Just represents an arbitrary monad
convertM   = Just . convert
data_ = [1..5]

ffp = filter           predicate  data_
ffm = filterM          predicateM data_
fcp = [a | a <- data_, predicate  a]
fcm = [a | a <- data_, predicateM a]

mfp = map        convert           data_
mfm = mapM       convertM          data_
mcp =          [ convert  a | a <- data_ ]
mcm = sequence [ convertM a | a <- data_ ]

编辑：

需要注意的是，名称以m 结尾的版本必须使用convertM 或predicateM：在这些情况下，普通的convert 和predicate 不可用；这就是问题的重点。

背景资料

动机源于拥有一堆函数（这里是一个简化的集合，希望具有代表性）

convert   ::  a  -> r -> b
predicate ::  a  -> r -> Bool
big       :: [a] -> r -> [b]

big as r = [ convert a r | a <- as, predicate a r ]

请求根据 Reader 进行重构...其中之一 (big) 使用其他之一 (predicate) 作为 listcomp 保护中的谓词。

只要将 listcomp 替换为 mapM 和 filterM 的组合，重构就可以正常工作：

convertR   ::  a  -> Reader r b
predicateR ::  a  -> Reader r Bool
bigR       :: [a] -> Reader r [b]

bigR as = mapM convertR =<< filterM predicateR as

这样做的问题是，在现实生活中，listcomp 复杂得多，而对mapM 和filterM 的转换则远没有那么干净。

因此，即使谓词变成单子，也希望保留 listcomp。

编辑 2

真正的 listcomp 更复杂，因为它结合了多个列表中的元素。我试图将问题的本质提取到以下示例中，这与编辑1不同

• big 中的 listcomp 从多个列表中获取数据。
• predicate 接受多个值作为输入。
• convert 已重命名为 combine 并接受多个值作为输入。
• Reader 版本的类似更改。

.

combine   :: r -> (a,a) -> b
predicate :: r -> (a,a) -> Bool
big, big' :: r -> [a]   -> [b]

big  r as = [ combine r (a,b) | a <- as, b <- as, predicate r (a,b) ]
big' r as = map (combine r) $ filter (predicate r) $ [ (a,b) | a <- as, b <- as ]

combineR    :: (a,a) -> Reader r b
predicateR  :: (a,a) -> Reader r Bool
bigR, bigR' :: [a]   -> Reader r [b]

bigR     = undefined
bigR' as = mapM combineR =<< filterM predicateR =<< return [ (a,b) | a <- as, b <- as ]

big' 是对big 的重写，其中combine 和predicate 是从listcomp 中提取的。这在阅读器版本中有一个直接等效项：bigR'。所以，问题是，你怎么写bigR应该是

1. 没有明显比bigR'丑
2. 尽可能直接翻译big。

在这个阶段，我很想得出结论，bigR' 已经达到了预期效果。这意味着我的问题的答案是：

• 保留用于构造笛卡尔积的 listcomp
• 将 predicate 和 combine 从表达式中分别移到 filter 和 map 中
• 在单子版本中，将filter 和map 替换为filterM 和mapM（以及将$ 替换为=<<）。
• 取消对谓词和组合函数的柯里化：listcomp 与柯里化和非柯里化版本同样适用，但映射过滤器组合需要对它们进行柯里化。在这个阶段，这可能是失去使用 listcomp 能力的最大代价。

Answer 1

就我个人而言，我想不出用只是一个列表组合的方法，但这可能会让你更接近？ （我列出了我经历的一些中间步骤，以便您可以根据需要采取不同的方向）。

{-# LANGUAGE MonadComprehensions #-}

predicateM = return . (>3)
[[a | True <- predicateM a] | a <- [1,2,3,4,5]] 
  :: (Num b, Ord b, Control.Monad.Fail.MonadFail m) => [m b]
[[if b then Just a else Nothing | b <- predicateM a] | a <- [1,2,3,4,5]]
  :: (Num a, Monad m, Ord a) => [m (Maybe a)]
[[bool Nothing (Just a) b | b <- predicateM a] | a <- [1,2,3,4,5]]
  :: (Num a, Monad m, Ord a) => [m (Maybe a)]
catMaybes <$> sequence [[bool Nothing (Just a) b | b <- predicateM a] | a <- [1,2,3,4,5]]
  :: (Monad f, Num a, Ord a) => f [a]

filterM' p xs = catMaybes <$> sequence [[bool Nothing (Just a) b | b <- p a] | a <- xs]

ListT 可能会更简洁？

编辑：另一种方法，尽管它会发出一些关于ListT 提供非法实例的警告..

unListT (ListT x) = x
filterM'' p xs = unListT [a | (a,True) <- ListT $ mapM (\x -> return . (x,) =<< p x) xs]

EDIT2：好的，我把它归结为一个单一的理解！

filterM''' :: (Traversable m1, Monad m2, Monad m1, Alternative m1) => (b -> m2 Bool) -> m1 b -> m2 (m1 b)
filterM''' p xs = [[a | (a,b) <- mlist, b] | mlist <- mapM (\x -> return . (x,) =<< p x) xs]

EDIT3：另一种方法，因为我不确定您需要访问什么。

filterM' p xs = [x | x <- filterM p xs]

然后，嵌套理解以获得对“内部”元素类型的访问，例如。过滤和映射，

filterMap f p xs = [[f x | x <- mlist] | mlist <- filterM p xs]

Answer 2

import Control.Monad.Trans.Reader
import Control.Monad (filterM)

这个问题的动机是希望获得表单的某些功能

f ::  x  ->  y  ->  z ->   a                 ; f  = undefined
p ::  x  ->  y  ->  z -> Bool                ; p  = undefined
u :: [x] -> [y] -> [z] -> [a]

并在某些上下文中将它们替换为类似的（在此示例中为Reader）：

fR ::  x  ->  y  ->  z  -> Reader r  a        ; fR = undefined
pR ::  x  ->  y  ->  z  -> Reader r Bool      ; pR = undefined
uR :: [x] -> [y] -> [z] -> Reader r [a]

问题的核心是，其中一个原始函数具有多输入列表推导式，它使用其他函数进行组合和过滤：

u xs ys zs = [ f x y z | x <- xs, y <- ys, z <- zs, p x y z ]

该问题解决了实现等效的上下文uR 函数的困难；特别是明显丧失使用列表推导的能力及其便利性。

u 相当简洁地翻译成结合了列表理解的实现，filter 和 map。这在下面显示为u'。 u' 有直接翻译成上下文版本，uR：

u' xs ys zs = map  ucf  $   filter  ucp  $           cartesian xs ys zs
uR xs ys zs = mapM ucfR =<< filterM ucpR =<< return (cartesian xs ys zs)

在上面，列表推导被打包在cartesian

cartesian xs ys zs = [ (x,y,z) | x <- xs, y <- ys, z <- zs ]

并且该解决方案要求原始函数（p、f、pR 和 fR）未被curried：

ucp = uncurry3 p     ;    ucpR = uncurry3 pR
ucf = uncurry3 f     ;    ucfR = uncurry3 fR

uncurry3 :: (a -> b -> c -> r) -> (a, b, c) -> r
uncurry3 f = \(a,b,c) -> f a b c

也许这个解决方案可以加上单子理解，但我现在没有时间考虑这个。