Do not use try..finally in recursive functions

Recently I stumbled upon a post in Moirae Software blog. It was about hunting a memory leak in a F# application. What was interesting about the leak that it was caused by non-tail recursive call, however the call seemed to be tail at first glance. It turned out that tail calls is full of rather subtle pitfalls. For further information on the topic I recommend this F# team blog post. As a real engineer, I must check everything myself :) This is the results:

	// 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

view raw gistfile1.fs hosted with ❤ by GitHub

In short, the F# team folks are absolutely right - recursive calls from try...with/try...finally block are not tail. In case of non-async (plane) functions it follows to quick stack overflow exception. In case of async functions things gets a bit more interesting due to continuations created by Async expression builder. Although the continuations have 'fixed' the stack overflow problem (effectively have hidden it), the result is even more dangerous - a memory leak. Conclusion is simple:

• Never, ever do recursive calls from try...with/try...finally blocks!
• Never, ever use either 'use' nor 'use!' in recursive functions!