haskell - Haskell 中的半独立 Action

Question

我正在寻找一个 Haskell 设计，以某种方式组成一系列单子(monad)操作(通常是 IO)，后面的操作依赖于先前的操作，但在某些情况下可以在完成之前执行。

到目前为止我想出的解决方案是:

type Future m a = m (m a)

读取:一个单子(monad)操作，它启动某个进程并返回一个操作，该操作将返回该过程的结果(可能通过等待该过程完成)。

因此，在某个链中 a >>= b >>= c b 得到一个返回 a 结果的操作。如果 b 评估此操作，它将等待 a 完成，否则它将并行运行。这也意味着，如果某个操作不需要前一个操作的结果作为参数，则根据定义，它不依赖于该操作，因此依赖关系是显式的。

一些示例代码:

date :: Future IO String   -- long process to find out the date
date = do
    print "attempting to get date"  -- will usually start some thread or process to compute the date
    return (print "today")  -- will wait for this thread or process and return the computed date

main = do
    d <- date   -- starts recieving the date
    print "foo" -- some other process
    d >>= print -- waits until the date has been computed and prints it out

输出:

"attempting to get date"
"foo"
"today"

有一个问题:如果一个操作决定等待前一个操作，它将始终依赖于之前的所有其他操作(在我的例子中)。但在上面的示例中，如果 c 决定等待 b 但 b 没有决定等待 a，则 c 可能会在 a 完成之前启动，这是不应该发生的。

作为解决方案，我编写了另一个组合运算符:

(>=>) :: Monad m => Future m a -> (m a -> Future m b) -> Future m b
a >=> f = do
    r1 <- a
    r2 <- f r1
    return (r1 >> r2)

因此，这将结合“等待操作”，并且 a >=> b >=> c 将正常工作，如果 c 等待 b，则此等待操作也将等待 a。然而，这种方法还有另一个问题(除了您需要记住使用 >=> 而不是 >>=):WAITING操作可能会被评估多次。如果 b 等待 a，c 等待 b，则 b 的等待仍然会与 a 的等待相连，因此 a 的等待将被执行两次。

实际问题在于 >=>:fr1 可能会计算 r1，在这种情况下，它不需要在 return 语句中与 r2 一起排序(因为它已经被执行，因此 a 有完成的)。但也可能不会，我不知道。

所以我基本上想要的正是这个，但不可能多次运行等待操作。不幸的是我在功能设计方面经验不是很丰富。

因此，我希望您能以某种方式启发我如何增强或改变我的设计，或者为我指出一种不同的、更灵活的方法。

编辑根据到目前为止的答案，我想对我真正想要的内容进行更多说明:

我不想推迟(甚至跳过)操作的执行，也不需要线程或类似的并行功能。实际上我正在调用外部进程。一个例子是

backup :: Future IO ExitCode
backup = do
    pid <- startProcess "backup"
    return (waitForProcessAndGetExitCode pid)

当我现在链接诸如 backup >=> otherAction 之类的操作时，otherAction 可以在备份运行时运行(这总体上节省了很多时间)。但otherAction可能需要备份完成，此时可以使用其参数来等待备份并检查备份是否成功。无论哪种方式，都必须执行备份。

我现在正在寻找一个很好的通用解决方案，最好不依赖于 IO monad。

更新我找到了一个适合我的解决方案。我在下面的单独答案中对此进行了描述。

Answer 1

我很确定您确实想要这个签名:

(>>=) :: Future m a -> (a -> Future m b) -> Future m b

以下是实现您想要的内容的方法:

import Control.Concurrent
import Control.Monad
import Control.Monad.Trans

newtype Future m a = Future { runFuture :: m (m a) }

instance (Monad m) => Monad (Future m) where
    return = Future . return . return
    m >>= f = Future $ do
        fut1 <- runFuture m
        return $ join $ join $ liftM (runFuture . f) fut1

instance MonadTrans Future where
    lift = Future . liftM return

换句话说，Future 是一个 monad 转换器，其实现没有任何内容专门针对 IO monad。但是，以下示例将展示如何将其与 IO monad 结合使用来链接 future:

parallel :: IO a -> Future IO a
parallel m = Future $ do
    v <- newEmptyMVar
    forkIO $ m >>= putMVar v
    return $ takeMVar v

future1 = parallel $ do
    threadDelay 1000000
    putStrLn "Hello, World" 
    return 1
future2 n = parallel $ do
    threadDelay 1000000
    print n
    return 2
future3 = future1 >>= future2

main = do
    f <- runFuture future3
    putStrLn "I'm waiting..."
    r <- f
    print r

我还没有证明它满足单子(monad)定律或单子(monad)变换定律，但我会尝试这样做，并且我会向您通报它是否符合要求。在那之前，其中的某个地方可能存在错误的连接。

编辑:不!差远了。它绝对不满足单子(monad)定律。我不知道我是否接近，但暂时假设这个答案是不正确的。不过，我现在有点好奇，想知道这是否可能。