12

我有一些从 Haskell 调用的用 C 语言编写的函数。这些函数返回IO (CInt). 有时我想运行所有函数，而不管它们返回什么，这很容易。为了示例代码，这是当前正在发生的事情的一般概念：

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

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

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

这给了我这个错误：

<交互式>:1:22:
    无法将预期类型“[b]”与推断类型“IO a”匹配
    在 `mapM' 的第一个参数中，即 `f'
    在`($)'的第二个参数中，即`mapM f([0 .. 5])'
    在表达式中：takeWhile (< 4) $ mapM f ([0 .. 5])

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

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

这是适合函子的解决方案吗？Functors 还没有和我一起“点击”，但我有一种印象，这可能是使用它们的好情况。

更新：

@sth 有我想要的最接近的答案 - 事实上，这几乎正是我想要的，但我仍然想看看是否有一个标准解决方案不是明确递归的 - 这是 Haskell，之后全部！回顾我如何表达我的问题，现在我可以看到我对我想要的行为不够清楚。

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 的答案执行了我想要的确切行为，除了结果可能（应该？）被丢弃。一个dropWhileM_函数对于我的目的来说是等价的。takeWhileM_为什么在 Control.Monad中没有这样的函数？我看到在邮件列表上有类似的讨论，但似乎没有任何结果。

4

5 回答 5

16

您可以将序列定义为

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)

如下使用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 不是MonadPlus的实例。

所以多握住它的手

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

注意 that 的使用[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
于 2009-07-16T14:47:37.560 回答
14

我认为标准库中没有类似 atakeWhileM的东西，但是您可以自己编写它，以便只执行所需的 IO：

takeWhileM :: (Monad m) => (a -> Bool) -> [m a] -> m [a]
takeWhileM _ [] = return []
takeWhileM p (a:as) =
   do v <- a
      if p v
         then do vs <- takeWhileM p as
                 return (v:vs)
         else return []

仅在找到与谓词不匹配的元素之前评估提供的列表：

*Main> takeWhileM (<4) (map f [1..5])
1
2
3
4
[1,2,3]
于 2009-07-15T21:32:41.690 回答
12

编辑：现在我看到了你在找什么。

gbacon 发布了一个不错的sequenceWhile功能，这几乎是您需要的“原始”。

实际上，既然您只对副作用感兴趣，sequenceWhile_应该就足够了。这是一个定义（再次受到 gbacon 的启发，请投票给他！）：

sequenceWhile_ :: (Monad m) => (a -> Bool) -> [m a] -> m ()
sequenceWhile_ p xs = foldr (\mx my -> mx >>= \x -> when (p x) my)
                            (return ()) xs

你这样称呼它：

Prelude Control.Monad> sequenceWhile (<4) $ map f [1..]

原答案：

您不能只是“取消”从IOMonad 中使用的值takeWile，但您可以“取消”takeWhile以在 Monad 中使用！

liftM函数会将一个函数(a -> b)转换为一个函数(m a -> m b)，其中是m一个 Monad。

（作为旁注，您可以通过在Hoogle上搜索其类型来找到这样的函数，在这种情况下通过搜索Monad m => (a -> b) -> (m a -> m b)：）

你liftM可以这样做：

Prelude> :m + Control.Monad
Prelude Control.Monad> let f x = print x >> return x
Prelude Control.Monad> liftM (takeWhile (<4)) $ mapM f [0..5]
0
1
2
3
4
5
[0,1,2,3]

现在，这可能不是您想要的。在返回列表之前，mapM将按f顺序将该函数应用于整个列表。然后将该结果列表传递给提升的takeWhile函数。

如果要在第三个元素之后停止打印，则必须停止调用 print。这意味着，不要应用于f这样的元素。所以，你最终会得到一些简单的东西，比如：

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

顺便说一句，您是否想知道为什么 mapM会在返回列表之前先打印所有内容。您可以通过用它们的定义替换函数来看到这一点：

mapM f [0..1]
=
sequence (map f [0..1])
=
sequence (f 0 : map f [1..1])
=
sequence (f 0 : f 1 : [])
=
sequence ((print 0 >> return 0) : f 1 : [])
= 
sequence ((print 0 >> return 0) : (print 1 >> return 1) : [])
=
do x  <- (print 0 >> return 0)
   xs <- (sequence ((print 1 >> return 1) : []))
   return (x:xs)
=
do x  <- (print 0 >> return 0)
   xs <- (do y  <- (print 1 >> return 1)
             ys <- sequence ([])
             return (y:ys))
   return (x:xs)
=
do x  <- (print 0 >> return 0)
   xs <- (do y  <- (print 1 >> return 1)
             ys <- return []
             return (y:ys))
   return (x:xs)
=
do x  <- (print 0 >> return 0)
   xs <- (do y <- (print 1 >> return 1)
             return (y:[]))
   return (x:xs)
=
do x  <- (print 0 >> return 0)
   xs <- (print 1 >> return (1:[]))
   return (x:xs)
=
do x <- (print 0 >> return 0)
   print 1
   return (x:1:[])
=
do print 0
   print 1
   return (0:1:[])

这种用定义替换函数的过程称为等式推理。

如果我没有犯任何错误，您现在（希望）可以看到mapM（使用sequence）首先打印所有内容，然后返回一个列表。

于 2009-07-15T21:11:25.383 回答
6

您可以使用“列表”包中的一个。

import Control.Monad.ListT (ListT)
import Data.List.Class (execute, fromList, joinM, takeWhile)
import Prelude hiding (takeWhile)

f x = print x >> return x
main =
  execute . takeWhile (< 4) .
  joinM $ fmap f (fromList [0..5] :: ListT IO Int)
  • fromList [0..5]创建一个包含 0..5 的单子列表，它不执行单子操作
  • fmap f到那个列表会导致 aListT IO (IO Int)仍然不执行单子动作，只包含单子​​动作。
  • joinM把它变成一个ListT IO Int. 当项目被消耗时，每个包含的动作都会被执行，其结果将是列表中的值。
  • takeWhile泛化为任何List。[]和 " Monad m => ListT m"都是List.
  • execute消耗一元列表，执行它的所有动作。
  • 如果您对结果感兴趣，可以使用"toList :: List m => m a -> ItemM m [a]"(" ItemM (ListT IO)" is IO)。所以在这种情况下它是“ toList :: ListT IO a -> IO [a]”。更好的是，您可以继续使用 , 等高阶函数scanl来处理正在执行的单子列表。
于 2009-07-15T23:35:22.097 回答
3

最近，您可以使用MonadList hackage，其中包括一些方便的函数，例如 takeWhileM、dropWhileM、deleteByM 等等。

于 2012-03-15T18:32:48.167 回答