[Haskell-cafe] ANN: Future 1.1.0 concurrency library

[John Van Enk]

I'd also like to point out that Chris did this with 165 lines of
code--including comments and whitespace! If you drop the whitespace and
comments, it's only 91 lines!

/jve


On Mon, Mar 9, 2009 at 4:54 PM, ChrisK <haskell at list.mightyreason.com>wrote:

> Hello,
>
>  As a side effect of the discussion of the new C++ future/promise features
> at http://lambda-the-ultimate.org/node/3221 I have implemented a Haskell
> package called "future" at
>
> http://hackage.haskell.org/cgi-bin/hackage-scripts/package/future
>
> This ought to do what C++ standard futures/promises do, plus a bit more.
>  The main operation is
>
> > forkPromise :: IO a -> IO (Promise a)
>
> This sets the "IO a" operation running in a fresh thread.  The eventual
> result can be accessed in many ways (non-blocking, blocking, blocking with
> timeout).
>
> > let one :: Int; one = 1
> > p <- forkPromise (return (one+one))
> > x <- get
> > y <- wait
>
> x is an Int with value 2.
> y is an (Either SomeException Int) with value (Right 2).
>
> The useful thing about futures, as opposed to various IVar packages, is
> handling  the case where the forked operation ends with an exception.  The
> exception becomes the return value of the promise.  The "get" operation
> rethrows it, the "wait" operation returns it as (Left ...).
>
> There is also an "abort" command to kill a promise.  The dead promise may
> then have an exceptions as its value.
>
> The "plus a bit more" than C++ is the nonblocking "addTodo" feature.  This
> takes a continuation function from the "Either SomeException a" to an IO
> operation. These continuation functions get queued and they are run
> immediately after the the forked operation completes.  Once completed any
> new "addTodo" continuations run immediately.
>
> These continuations allow you to race a list of action and take the first
> one done, or to collect the answers as they complete into a Chan.  Both of
> those options are demonstrated in Future.hs as racePromises and
> forkPromises.
>
> It should be safe to use "unsafePerformIO . get" or "unsafePeformIO . wait"
> to get lazy access to the result, which is itself immutable once set.
>
> Cheers,
>  Chris
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20090309/935162c0/attachment.htm