@davidpodhola could you have a look at this? I wasn't able to make the the implementation the "same" for both TaskBuilder and TaskBuilderWithToken and keep all tests green -- I had to disable run delay law.
also, why does Delay have to have the type (f : unit -> Task<'a>) : unit -> Task<'a>, when this doc says it should be (f : unit -> Task<'a>) : Task<'a>?

Hi,

I applaud you for actually contributing changes (rather than just whining like me).

I can answer your second question at least: the type signatures in the doc are really just suggestions. All that matters is that everything typechecks after the compiler desugars the computation expression to method calls. This means you can use a separate type to represent a delayed expression as long as the methods that will take delayed expressions handle that type. For example, the body of a while loop is always delayed, so while you could write (as the docs suggest):

member __.Delay(computation : unit -> M<'t>) = ... : M<'t>
member __.While(cond : unit -> bool, delayedBody : M<unit>) = ... : M<unit>

This approach works just as well (as long as you don't need any special custom behavior for your delayed exprs), and is probably the most common way to do it:

member __.Delay(computation : unit -> M<'t>) = computation
member __.While(cond : unit -> bool, delayedBody : unit -> M<unit>) = ... : M<unit>
                                                // ^^^^^^^^^^^^^^^
                                                // notice the type matches delay's return type

Anyway, from skimming your contribution, I think you fell victim to a bug that I also had with my own TaskBuilder implementation. If m completes without encountering any exceptions, but then an exception is thrown by compensation() in wrapOk, it's still in your TryWith so you'll run compensation() a second time via wrapCarsh (was this supposed to be named wrapCrash?). Concrete example:

try
    ()
finally
    printfn "ran!" // I think this will get printed twice.
    failwith "uhoh"

I think if you just move the Bind to the outside like this, that should fix the problem. Since wrapCrash raises its exception again you know that execution won't proceed to wrapOk if wrapCrash ran.

// instead of
// this.TryWith((fun () -> this.Bind(m(), wrapOk)), wrapCrash)
   this.Bind(this.TryWith(m, wrapCrash), wrapOk)

@rspeele thanks so much for spotting the mistake and the general overview! I think I'm getting now much better what's going on.
but what I still don't understand is why does Delay have to be fun () -> this.Bind(this.Return(), f) -- why is fun () -> f() not enough? or even just f?

@forki @mausch @panesofglass ping

thx

thanks for merging :)