Future in f# is this an unavoidable use of a mutable variable? I have this type:

type Future&lt;'a&gt; () =
    let mutable _value: 'a option = None

    member x.Resolve value =
        if _value.IsSome then failwith "can only resolve once"
        _value &lt;- Some value

    member x.IsResolved with get () = _value.IsSome

    member x.Value 
        with get () = 
            match _value with 
            | Some v -&gt; v
            | None -&gt; failwith "hasn't resolved yet"


And I need something like this because I have something along the lines of:

let testHttpGet response =
    let urlFuture = Future&lt;string&gt;()

    let get url = 
        urlFuture.Resolve url
        response

    (get, urlFuture)


Call that function and set the return value of the returned function

let get, urlFuture = testHttpGet "resp"


Call the returned func, thus resolving the Future

let response = get "http://test"


In the end we have the result of the function 

response |&gt; should equal "resp"


And we have the value with which the func was called

urlFuture.IsResolved |&gt; should be True
urlFuture.Value |&gt; should equal "http://test"


To me this looks like a sound approach but I also have a feeling that something like it must exist in f# allready 

Here's where I use them.

Here is a fiddle.
This looks pretty close to a Clojure Promise. On .NET, the similar type is (very Microsoftish) called TaskCompletionSource&lt;TResult&gt;.

However, you should consider if F# Lazy Computations isn't what you need.