Language: F# · Versions: F# 9.0 / .NET 9.0
The problem
F# 8/9 added the [<TailCall>] attribute so the compiler warns (FS3569) when a recursive function is not in tail position. However, when a recursive function appears to have its recursive call on the very last line, wrapping the body in use r = ... (IDisposable) or try ... with silently forces the compiler to keep the stack frame alive to run .Dispose() or the exception filter after the recursive call returns—defeating the .tail IL instruction and causing StackOverflowException at ~10,000 depth!
Minimal example
open System
type DummyScope() =
interface IDisposable with
member _.Dispose() = ()
[<TailCall>]
let rec loop (n: int) : int =
if n <= 0 then 0
else
// `use` desugars to `try ... finally r.Dispose()`, so `loop (n - 1)` is NOT a tail call!
use _scope = new DummyScope()
loop (n - 1)
Expected
[<TailCall>] flags loop (n - 1) at compile time, and we need a clean way to scope a disposable resource per iteration without growing the call stack.
What happens instead
Because use _scope = ... translates to try loop (n - 1) finally _scope.Dispose(), the recursive call is followed by the finally continuation and cannot emit the CIL tail. prefix. Without [<TailCall>], this compiles without a single warning and crashes with StackOverflowException in production when n is large.
What is the cleanest way in F# 9 to scope an IDisposable strictly to the current step before making the tail-recursive call (or inside tail-recursive Async / Task state machines) so [<TailCall>] succeeds with zero warnings?
Your example already gets the warning you want. The attribute is on loop, and use desugars to try ... finally, so loop (n - 1) is not in tail position. I'd expect FS3569 on that line. Without the attribute it compiles silently, as you say, but then there is nothing for the attribute to flag. I'm reasoning from the language spec and the [<TailCall>] design (F# 8+), not from a compiler run. The ~10,000 depth is also machine-dependent, since it depends on stack size and frame size.
Fix: end the scope before the recursive call
Put the scoped work in a non-recursive helper, then recurse from plain tail position:
open System
type DummyScope() =
interface IDisposable with
member _.Dispose() = ()
let private step (n: int) : unit =
use _scope = new DummyScope()
// per-iteration work that needs the resource
()
[<TailCall>]
let rec loop (n: int) : int =
if n <= 0 then 0
else
step n // scope is disposed when step returns
loop (n - 1) // genuine tail call, no warning
If the next iteration depends on the step's result, return it from step and pass it on: let next = step n in loop next.
An inline parenthesised block also works. A use inside ( ... ) ends at the closing paren:
(
use _scope = new DummyScope()
doWork n
)
loop (n - 1)
I prefer the helper because the scope boundary is explicit and harder to break during a refactor.
try/with follows the same rule
Wrap only the step, never the recursive call:
let result = try Ok (step n) with e -> Error e
match result with
| Ok () -> loop (n - 1)
| Error _ -> -1
Async and Task
In async { use s = ...; return! loop (n-1) } the use spans the return!, so every iteration's resource stays alive until the whole chain unwinds. That leaks scopes even if the stack is fine. Do the same split, with the scope in an inner block that completes first:
let rec loopA (n: int) : Async<int> =
async {
if n <= 0 then return 0
else
do! async {
use _scope = new DummyScope()
return ()
}
return! loopA (n - 1)
}
The same shape works with task { ... }. I haven't verified how stack-safe return! is in the task builder on .NET 9, so test that with a large n. [<TailCall>] is about IL tail. emission and doesn't tell you much about builder-based state machines.
What would settle it
Build with [<TailCall>] on and --warnaserror+:3569, then run loop 10_000_000 in Release. In Debug, tail calls are off by default (--tailcalls-), so only Release shows the real behaviour.