Proposal: Control.Concurrent.Async

[Heka Treep]

2012/6/8, Simon Marlow <marlowsd at gmail.com>:
> I'd like to add a higher-level concurrency API to the base package.
> This API has grown while I've been working on examples for my book, and
> I'm convinced that we should have something like this in the standard
> libraries.  Here's the API I propose:
>
> http://community.haskell.org/~simonmar/async-stm/Control-Concurrent-Async.html
>
> In fact it already exists in at least two packages on Hackage: 'async'
> and 'threads'.  My version is a superset of both of these, except for a
> few small differences (which are up for discussion, of course).
>
> One good reason to have this package is that it avoids some common
> pitfalls, such as forgetting to handle exceptions in your child threads.
>   In the Async API, you get to choose whether to (a) receive the result
> as 'Either SomeException a', or (b) have the exception re-thrown in the
> waiting thread.  You don't get to ignore it altogether.
>
> Another common pitfall avoided by this library is accidentally leaving
> threads running in the background.  This is handled by withAsync:
>
>    withAsync :: IO a -> (Async a -> IO b) -> IO b
>
> the child thread is always cancelled (i.e. killed) when the second
> argument returns or throws an exception, if it hasn't finished already.
>
>
> I'm opening this up for discussion so that we can tidy up any
> inconsistent details and add any functions that people feel are missing.
>   Naming is obviously up for discussion too.
>
> Cheers,
> 	Simon
>
>
>
> _______________________________________________
> Libraries mailing list
> Libraries at haskell.org
> http://www.haskell.org/mailman/listinfo/libraries
>

Hello, Simon.

I have noticed that the computation strategy plays a role for the
'async' function. For example:

asyncWaitCatch :: Int -> Int -> IO (Either String Int)
asyncWaitCatch m n = async (return $ m `div` n) >>= waitCatch >>=
return . either (const $ Left "divide by zero") Right

gives

-- > asyncWaitCatch 4 2
-- Right 2
-- > asyncWaitCatch 1 0
-- Right *** Exception: divide by zero

but

asyncWaitCatch :: Int -> Int -> IO (Either String Int)
asyncWaitCatch m n = async (return $! m `div` n) >>= waitCatch >>=
return . either (const $ Left "divide by zero") Right

gives

-- > asyncWaitCatch 4 2
-- Right 2
-- > asyncWaitCatch 1 0
-- Left "divide by zero"

as expected.

Also, in this kind of a higher-level interface, I would like to have
some form of message passing. It can be done with STM channels, for
example (I wrote a wrapper around threads and STM channels some times
ago, here is how it looks -
https://github.com/treep/hactors/blob/master/Control/Concurrent/Actor.hs).