Führen rekursive Sequenzen Speicherverlust aus?

Question

Ich mag Sequenzen rekursiv wie folgt definieren:

let rec startFrom x = 
    seq { 
     yield x; 
     yield! startFrom (x + 1) 
    } 

Ich bin nicht sicher, ob rekursive Sequenzen wie diese sollten in der Praxis verwendet werden. Die yield!erscheint, um rekursiv zu sein, aber ich bin nicht 100% sicher, da es von einem anderen IEnumerable aufgerufen wird. Aus meiner Sicht erstellt der Code bei jedem Aufruf eine Instanz von IEnumerable, ohne sie zu schließen, wodurch diese Funktion tatsächlich ebenfalls Speicher verliert.

Wird diese Funktion Leckspeicher? Ist es überhaupt "rekursiv"?

[Bearbeiten, um hinzuzufügen]: Ich fummle herum mit Nprof für eine Antwort, aber ich denke, es wäre hilfreich, eine technische Erklärung über die Implementierung von rekursiven Sequenzen auf SO zu erhalten.

Answer 1

ich bei der Arbeit bin jetzt so bei etwas neuere Bits Ich bin auf der Suche als Beta1, aber auf meiner Box in Release-Modus und dann auf den kompilierten Code mit .NET Reflector suchen, scheint es, dass diese beiden

let rec startFromA x =  
    seq {   
     yield x  
     yield! startFromA (x + 1)  
    } 

let startFromB x =  
    let z = ref x 
    seq {   
     while true do 
      yield !z 
      incr z 
    } 

fast identische MSIL-Code generieren, wenn im Modus 'Release' kompiliert. Und sie laufen bei etwa der gleichen Geschwindigkeit wie dieser C# -Code:

public class CSharpExample 
{ 
    public static IEnumerable<int> StartFrom(int x) 
    { 
     while (true) 
     { 
      yield return x; 
      x++; 
     } 
    } 
} 

(zum Beispiel lief ich alle drei Versionen auf meiner Box und druckte das millionste Ergebnis und jede Version dauerte etwa 1,3 s, +/- 1 s). (Ich habe kein Speicherprofil erstellt; es ist möglich, dass mir etwas Wichtiges fehlt.)

Kurz gesagt, würde ich nicht zu sehr darüber schwitzen, über solche Probleme nachzudenken, es sei denn, Sie messen und sehen ein Problem.

EDIT

Ich weiß, ich nicht wirklich die Frage beantworten haben ... Ich denke, die kurze Antwort ist „Nein, ist es nicht auslaufen“.(Es gibt einen speziellen Sinn, in dem alle ‚unendlich‘ IEnumerables (mit einem Cache gespeicherten Sicherungsspeicher) ‚Leck‘ (je nachdem, wie Sie definieren ‚Leck‘), siehe

Avoiding stack overflow (with F# infinite sequences of sequences)

für eine interessante Diskussion über IEnumerable (aka 'seq') gegen LazyList und wie der Verbraucher LazyLists eifrig konsumieren kann, um alte Ergebnisse zu "vergessen", um eine bestimmte Art von "Leck" zu verhindern.)

Answer 2

.NET-Anwendungen "lecken" nicht den Speicher auf diese Weise. Selbst wenn Sie viele Objekte erstellen, werden durch eine Garbage-Collection alle Objekte ohne Root-Rechte für die Anwendung selbst freigegeben.

Speicherverluste in .NET treten normalerweise in Form von nicht verwalteten Ressourcen auf, die Sie in Ihrer Anwendung verwenden (Datenbankverbindungen, Speicherstreams usw.). Instanzen wie diese, in denen Sie mehrere Objekte erstellen und dann auf sie verzichten, gelten nicht als Speicherverlust, da der Garbage Collector den Speicher freigeben kann.

Answer 3

Es wird keinen Speicher verlieren, es wird nur eine unendliche Sequenz generiert, aber da Sequenzen IEnumerables sind, können Sie sie ohne Speicherprobleme aufzählen. Die Tatsache, dass die Rekursion innerhalb der Sequenzgenerierungsfunktion stattfindet, hat keinen Einfluss auf die Sicherheit der Rekursion. Bedenken Sie, dass im Debug-Modus die Tail-Call-Optimierung deaktiviert sein kann, um ein vollständiges Debugging zu ermöglichen, aber in der Veröffentlichung wird es überhaupt kein Problem geben.