Q:

F#: Equivalent to OCaml Async

Does F# have an equivalent to OCaml's Async library? Specifically, the ability to easily make Deferred values and execute functions when they are filled?
In particular, I want to wait until a particular reference changes, and then do something. In OCaml, I'd do this by making an ivar and calling its read function; how can I do this in F#?

A:

Short answer
Yes, my Hopac library is a close relative of both Jane Street's Async library and the asynchronous workflows of F# among many others.  Hopac is based on Concurrent ML (CML) and arguably (as in technical terms rather than as a matter of opinion) currently provides a more expressive programming model than either of those.
Longer answer
Jane Street's Async's Deferred is much like .Net's Task.  Both are essentially comonadic abstractions with a monadic layer written on top.
In Hopac, the closest relative to a Deferred is actually a Promise.  However, Hopac doesn't directly provide a monadic layer for Promises.  Of course, you could easily write one, but I would advise to sit on it for awhile.  Rather, Hopac provides the Job monad for encoding light-weight threads.  This is analogous to how F#'s asynchronous workflows are defined and feels more natural and easier to reason about in my subjective opinion.
Jane Street's Async's Ivar is a close relative of Hopac's IVar.  Both descend from the same lineage.
What makes CML and Hopac more expressive than Jane Street's Async and F#'s asynchronous workflows is the availability of combinators for synchronous events (CML) or alternatives (Hopac).  Using those many kinds of concurrent protocols can be encapsulated as first-class, extensible (higher-order), selective operations.
CML's and Hopac's synchronous channels support simple rendezvous, which means that both ends of a communication agree when communication happens.  This, in turn, has some interesting applications such as the ability to implement Multicast channels that support garbage collectable publish-subscribe style communications without need to explicitly cancel subscription (contrast with Rx IObservable-IObserver).
Specific answer
Here is an F# interactive session that first defines an IVar and then starts a concurrent Job that reads the value of the IVar and prints a message.  Finally the IVar is written to with a value:
> let nameVar : IVar<string> = ivar () ;;
val nameVar : IVar<string>
> start (nameVar |>> fun who -> printfn "Hello, %s!" who) ;;
val it : unit = ()
> run (nameVar <-= "Vesa") ;;
val it : unit = ()
> Hello, Vesa!

To produce this output, F# interactive was started with the Hopac.fsx script.

