Erik Meijer and Matthew Podwysocki - Perspectives on Functional Programming

How are F# Asynchronous Workflows and Futures related? Could you implement asynchronous values with the same interface as futures/lazy values/promises?

For example, assuming we have a promise library with these operations:

1) p = new Promise() creates a new promise
2) p.value <- val assigns val as the value of the promise
3) p.value returns the value of the promise, or blocks the thread if nobody assigned a value yet

Pseudo code:

class Promise<T> {
    private T _value;
    private handle;

    public Promise() {
        handle = new ManualResetEvent(false)
    }

    public T value {
      get { handle.WaitOne(); return _value }
      set { _value = value; handle.Set() }
    }
}

You could implement a download function like this:

download :: string -> Promise<Stream>
download url =
    let p = new Promise()
    let req = HttpWebRequest.Create(url)
    req.BeginGetResponse(res => p.value <- res) // ommited boilerplate to extract the stream here
    p

Use it like this:

let page1 = download "foo.com"
let page2 = download "bar.com"
print page1.value
print page2.value

You can extract a pattern. If you have a value of type a, but the value is asynchronous (like a web page); it's really a function that you give a callback to:

simple value: b
async value: Async<b> = (b -> ()) -> ()  // (b -> ()) is the callback

So it's a like a request in the above example: you don't have the actual web page, but you have a function that you can call (BeginGetResponse) and this function calls your callback when the web page arrives.

We can extract the pattern of taking an async value and producing a promise out of it.

async :: Async<b> -> Promise<b>
async ayncval =
    let p = new Promise()
    asyncval (val => p.value <- val)
    p

And implement download like this:

download url = async HttpWebRequest.Create(url).BeginGetResponse

Or if you don't support partial application:

download url = async (callback => HttpWebRequest.Create(url).BeginGetResponse(callback))

Why did the F# team go for asynchronous workflows instead of this approach?