gistfile1.fs

// plane function, everything is OK
let rec loop n = 
    if n % 1000 = 0 then printfn "%d" n
    loop (n + 1)
loop 0

// plane function with recursive call from try...with, stack overflow exception after ~12K iterations
let rec loop n = 
    try
        if n % 1000 = 0 then printfn "%d" n
        loop (n + 1)
    with _ -> ()
loop 0

// subtle case: plane function with implicite try...finally (use keyword), stack overflow exception
let rec loop n =
    use d = { new IDisposable with member x.Dispose() = () }
    if n % 1000 = 0 then printfn "%d" n
    loop (n + 1) 
loop 0

// async function without try...with, everything is OK
let rec loop n = async {
    if n % 1000 = 0 then printfn "%d" n
    return! loop (n + 1) 
}
loop 0 |> Async.RunSynchronously

// async function with recursive call from try...with, memory leak ~60B per iteration (!)
let rec loop n = async {
    try
        if n % 1000 = 0 then printfn "%d" n
        return! loop (n + 1) 
    with _ -> () 
}
loop 0 |> Async.RunSynchronously

// subtle case: async function with implicite try...finally (use keyword), memory leak
let rec loop n = async {
    use d = { new IDisposable with member x.Dispose() = () }
    if n % 1000 = 0 then printfn "%d" n
    return! loop (n + 1) 
}
loop 0 |> Async.RunSynchronously

// another subtle case: async function with implicite try...finally (use! keyword), memory leak
let rec loop n = async {
    use! d = async { return { new IDisposable with member x.Dispose() = () }}
    if n % 1000 = 0 then printfn "%d" n
    return! loop (n + 1) 
}
loop 0 |> Async.RunSynchronously