Haskell：单子 takeWhile？

我有一些用 C 编写的函数，我从 Haskell 调用它们。这些函数返回IO (CInt)。有时我想运行所有函数，无论它们返回什么，这很容易。为了示例代码，这是当前发生的情况的总体思路：

Prelude> let f x = print x >> return x
Prelude> mapM_ f [0..5]
0
1
2
3
4
5
Prelude>

我得到了我想要的副作用，而且我不在乎结果。但现在我需要在第一个项目未返回我想要的结果后立即停止执行。假设返回值 4 或更高需要执行停止 - 那么我want要做的是：

Prelude> takeWhile (<4) $ mapM f [0..5]

这给了我这个错误：

<interactive>:1:22:
    Couldn't match expected type `[b]' against inferred type `IO a'
    In the first argument of `mapM', namely `f'
    In the second argument of `($)', namely `mapM f ([0 .. 5])'
    In the expression: takeWhile (< 4) $ mapM f ([0 .. 5])  

这对我来说很有意义 - 结果仍然包含在 IO monad 中，而且我不能只比较 IO monad 中包含的两个值。我知道这正是 monad 的目的——将结果链接在一起并在满足特定条件时丢弃操作——但是在这种情况下有没有一种简单的方法来“包装”IO monad 以停止根据条件执行链我选择的，没有写一个实例MonadPlus?

我可以“取消”其中的值吗f，为了 takeWhile 的目的？

这是函子适合的解决方案吗？函子还没有与我“合拍”，但我有这样的印象：这可能是使用它们的好情况。

@sth 对我想要的有最接近的答案 - 事实上，这几乎正是我想要的，但我仍然想看看是否有standard不是显式递归的解决方案——毕竟这是 Haskell！回顾我如何措辞我的问题，现在我发现我对自己想要的行为还不够清楚。

The f我上面用于示例的函数只是一个示例。真正的函数是用 C 编写的，并且专门用于其副作用。我不能使用@Tom的建议mapM_ f (takeWhile (<4) [0..5])因为在执行之前我不知道任何输入是否真的会导致成功或失败。

我实际上也不关心返回的列表——我只想调用 C 函数，直到列表耗尽或第一个 C 函数返回失败代码。

在 C 风格的伪代码中，我的行为是：

do {
    result = function_with_side_effects(input_list[index++]);
} while (result == success && index < max_index);

再说一次，@sth 的答案执行了我想要的确切行为，除了结果可能（应该？）被丢弃。 AdropWhileM_对于我的目的来说，函数是等效的。为什么没有这样的功能或者takeWhileM_在 Control.Monad 中？我看到有邮件列表上的类似讨论，但似乎没有任何结果。

你可能会定义sequence as

sequence xs = foldr (liftM2 (:)) (return []) xs

问题在于liftM2你一直看到的是你没有机会停下来m2，这可能是launchTheMissiles!

liftM2 :: (Monad m) => (a -> b -> c) -> m a -> m b -> m c
liftM2 f m1 m2 = do
    x1 <- m1
    x2 <- m2
    return (f x1 x2)

Using guard如下所示似乎很有吸引力：

sequenceUntil p xs = foldr (myLiftM2 p (:)) (return []) xs
  where myLiftM2 p f m1 m2 = do
            x1 <- m1
            guard $ p x1
            x2 <- m2
            return (f x1 x2)

上面的代码将在您的应用程序中失败，因为 IO monad 不是莫纳德加.

所以多握住它的手一点

module Main where

import Control.Monad

printx :: Int -> IO Int
printx x = do
    print x
    return x

sequenceUntil :: (Monad m) => (a -> Bool) -> [m a] -> m [a]
sequenceUntil p xs = foldr (myLiftM2 (:) []) (return []) xs
  where myLiftM2 f z m1 m2 = do
            x1 <- m1
            if p x1 then do x2 <- m2
                            return $ f x1 x2
                    else return z

main :: IO ()
main = do
  let as :: [IO Int]
      as = map printx [1..10]
  ys <- sequenceUntil (< 4) as
  print ys

虽然as是 1 到 10 之间的操作列表，输出为

1
2
3
4
[1,2,3]

丢弃结果就很简单了：

sequenceUntil_ :: (Monad m) => (a -> Bool) -> [m a] -> m ()
sequenceUntil_ p xs = sequenceUntil p xs >> return ()

main :: IO ()
main = do
  let as :: [IO Int]
      as = map printx [1..]
  sequenceUntil_ (< 4) as

注意使用[1..]显示新的组合器保持懒惰.

您可能更喜欢spanM:

spanM :: (Monad m) => (a -> Bool) -> [m a] -> m ([a], [m a])
spanM _ [] = return ([], [])
spanM p (a:as) = do
  x <- a
  if p x then do (xs,bs) <- spanM p as
                 return (x:xs, bs)
         else return ([x], as)

请注意，它与span因为它在结果列表中包含失败的元素。两人的第二个任务是剩下的行动。例如：

*Main> (xs,bs) <- spanM (< 4) as
1
2
3
4
*Main> xs  
[1,2,3,4]
*Main> sequence bs
5
6
7
8
9
10
[5,6,7,8,9,10]

还有另一种选择：

untilM :: Monad m => (a -> Bool) -> [m a] -> m ()
untilM p (x:xs) = do
  y <- x
  unless (p y) $ untilM p xs

请注意，谓词的含义是补足的：

*Main> untilM (>= 4) as
1
2
3
4