Proposal: Control.Concurrent.Async

[Gábor Lehel]

On Tue, Jun 12, 2012 at 12:58 PM, Simon Marlow <marlowsd at gmail.com> wrote:
> I think that now addresses all the comments that people had.
>
> There's one more change I'm thinking about: perhaps instead of
>
>  wait      :: Async a -> IO (Either SomeException a)
>  waitThrow :: Async a -> IO a
>
> we should reverse the naming scheme, rename waitThrow to wait and wait to
> something else (waitCatch?).  Rationale: waitThrow seems to be the version
> we need most often, and it's simpler to use.
>
>  wait      :: Async a -> IO a
>  waitCatch :: Async a -> IO (Either SomeException a)
>
> Thoughts? Better names for waitCatch?
>
> Latest Haddocks:
>
>  http://community.haskell.org/~simonmar/async/

Two small ones:

- In the documentation for cancel: "Has no effect if the Async has
already", it seems like something might have been cut off.

- Can we find a more accurate name for tryWait? It doesn't try and
possibly fail to wait, it avoids waiting altogether. Maybe don'tWait,
although that doesn't say what it does do. The only other idea I have
is 'check' which is not very descriptive...


>
> Repo:
>
>  https://github.com/simonmar/async
>
> Cheers,
>        Simon
>
>
>
>
>> On 8 June 2012 09:37, Simon Marlow<marlowsd at gmail.com>  wrote:
>>>
>>> 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
>>
>>
>>
>>
>
>
> _______________________________________________
> Libraries mailing list
> Libraries at haskell.org
> http://www.haskell.org/mailman/listinfo/libraries



-- 
Work is punishment for failing to procrastinate effectively.