Stack-Überlauf trotz Position Endaufruf aber nur in 64-Bit-

Question

von this question Entstanden, habe ich dieses kleine F # -Code (github) Zufallswerte zu erzeugen, gemäß einer Normalverteilung:

// val nextSingle : (unit -> float32) 
let nextSingle = 
    let r = System.Random() 
    r.NextDouble >> float32 

// val gauss : (float32 -> float32 -> seq<float32>) 
let gauss mean stdDev = 
    let rec gauss ready = seq { 
     match ready with 
     | Some spare -> 
      yield spare * stdDev + mean 
      yield! gauss None 
     | _ -> 
      let rec loop() = 
       let u = nextSingle() * 2.f - 1.f 
       let v = nextSingle() * 2.f - 1.f 
       let s = pown u 2 + pown v 2 
       if s >= 1.f || s = 0.f then loop() else 
       u, v, s 
      let u, v, s = loop() 
      let mul = (*)(sqrt(-2.f * log s/s)) 
      yield mul u * stdDev + mean 
      yield! mul v |> Some |> gauss 
    } 
    gauss None 

Ich scheint es, dass Dieser sollte sich nur in Tail-Call-Position aufrufen, ergo nie einen StackOverflowException verursachen, wenn TCO aktiviert ist. Aber es tut beim Ausführen 64-Bit. Es nicht beim Ausführen 32-Bit (d. H. "Prefer 32-Bit" Kontrollkästchen in den Projekteinstellungen).

Ich verwende .NET Framework 4.5.2 und F # 4.4.0.0.

Kann jemand erklären, was das Problem verursacht?

Answer 1

Sieht aus wie ein Fehler im Kompilierungsmechanismus des Sequenzausdrucks. Hier ist eine vereinfachte Repro:

let rec loop r = seq { 
    if r > 0 then 
     let rec unused() = unused() 
     yield r 
     yield! loop r 
} 

printfn "%i" (Seq.nth 10000000 (loop 1)) 

Offensichtlich ist die Anwesenheit der nicht verwendeten rekursiven Definition soll nicht beeinflussen, ob dieser einen Stapelüberlauf erzeugt, aber es funktioniert.