Seq.cache memory retention with captured closures in recursive sequences

Context

F# Seq.cache memoizes enumerated elements into an internal buffer, retaining every visited item for the lifetime of the cached sequence object. When the source sequence is produced by a recursive seq expression that captures outer variables in its closure, those captured values remain rooted as long as the cached sequence is reachable.

Goal

Determine the precise conditions under which the internal buffer and any captured closure references become eligible for garbage collection when a cached sequence is partially enumerated and then abandoned.

Constraints and uncertainty

• The buffer is cleared only when the cached enumerator is disposed or the sequence object becomes unreachable; partial enumeration followed by dropping all references to the IEnumerable<T> should allow collection, but the interaction with closure capture in recursive let rec sequences is not explicitly documented.
• JIT tail-call behavior varies by runtime version and architecture, which affects whether recursive sequence frames remain on the stack and keep closures alive.
• No universal threshold distinguishes normal caching from a leak; workload-dependent growth must be measured.

Questions

1. Does disposing the enumerator returned by Seq.cache immediately release the buffered elements and any captured closure references, or does the cache object itself retain them until finalization?
2. When a recursive seq expression captures a large array and is wrapped with Seq.cache, does partial enumeration followed by releasing all references to the cached sequence allow the captured array to be collected on .NET 8+ across x64 and ARM64?
3. Are there documented guarantees about buffer clearing behavior in the F# core library source, or is the current behavior an implementation detail subject to change?