如何评估 Maybe 列表的最佳实践

Question

我正在寻找一个函数，它接受一个函数 (a -> a -> a) 和一个 [Maybe a] 列表并返回 Maybe a。胡格尔没有给我任何有用的东西。这看起来是一个很常见的模式，所以我想问这种情况是否有最佳实践？

>>> f (+) [Just 3, Just 3]
Just 6
>>> f (+) [Just 3, Just 3, Nothing]
Nothing

提前致谢，克里斯

Answer 1

您应该首先将 [Maybe a] 转换为包含所有 Just 元素的 Maybe [a]（产生 Nothing 如果其中任何一个是Nothing）。
这可以使用 sequence，使用 Maybe 的 Monad 实例：

GHCi> sequence [Just 1, Just 2]
Just [1,2]
GHCi> sequence [Just 1, Just 2, Nothing]
Nothing

序列的定义 等价于以下内容：

sequence [] = return []
sequence (m:ms) = do
  x <- m
  xs <- sequence ms
  return (x:xs)

因此我们可以将后一个示例扩展为：

do x <- Just 1
   xs <- do
       y <- Just 2
       ys <- do
           z <- Nothing
           zs <- return []
           return (z:zs)
       return (y:ys)
   return (x:xs)

使用 monad 法则的 do-notation 表达式，我们可以将其重写如下：

do x <- Just 1
   y <- Just 2
   z <- Nothing
   return [x, y, z]

如果你知道 Maybe monad 是如何工作的，你现在应该明白 sequence 是如何实现的这期望的行为。 :)

然后，您可以使用 (<$>) （来自 Control.Applicative；相当于 fmap或 liftM）将二进制函数折叠到列表上：

GHCi> foldl' (+) 0 <
gt; sequence [Just 1, Just 2]
Just 3

当然，您可以使用任何您想要的折叠，例如 foldr、foldl1 等 另外，

如果您希望列表为空时结果为 Nothing，从而能够省略折叠的零值而不用担心空列表上的错误，那么您可以使用 .这个折叠函数：

mfoldl1' :: (MonadPlus m) => (a -> a -> a) -> [a] -> m a
mfoldl1' _ [] = mzero
mfoldl1' f (x:xs) = return $ foldl' f x xs

和类似的foldr、foldl 等。您需要导入 Control.Monad 为此。

然而，它的使用方式必须略有不同：

GHCi> mfoldl1' (+) =<< sequence [Just 1, Just 2]
Just 3

or

GHCi> sequence [Just 1, Just 2] >>= mfoldl1' (+)
Just 3

这是因为，与其他折叠不同，结果类型看起来像 m a 而不是 a；它是一个绑定而不是映射。

Answer 2

据我了解，您想要获得一堆可能的总和，或者如果其中任何一个是Nothing，则Nothing。这实际上非常简单：

maybeSum = foldl1 (liftM2 (+))

您可以将其概括为：

f :: Monad m => (a -> a -> a) -> [m a] -> m a
f = foldl1 . liftM2

当与 Maybe monad 一起使用时，f 完全按照您想要的方式工作。

如果您关心空列表，可以使用此版本：

f :: MonadPlus m => (a -> a -> a) -> [m a] -> m a
f _ []      = mzero
f fn (x:xs) = foldl (liftM2 fn) x xs

Answer 3

或者

λ Prelude > fmap sum . sequence $ [Just 1, Just 2]
Just 3
λ Prelude > fmap sum . sequence $ [Just 1, Just 2, Nothing]
Nothing

，通过使用 (+)：

λ Prelude > fmap (foldr (+) 0) . sequence $ [Just 1, Just 2]
Just 3
λ Prelude > fmap (foldr (+) 0) . sequence $ [Just 1, Just 2, Nothing]
Nothing

那么， maybeSum = fmap sum 。序列。