Woher wissen Sie, wann Sie Fold-Left und wann Fold-Right verwenden müssen?

Ich bin mir bewusst, dass Linksfalte linksgerichtete Bäume und Rechtsfalte rechtsgerichtete Bäume hervorbringt, aber wenn ich nach einer Falte greife, bin ich manchmal in kopfschmerzauslösenden Gedanken versunken und versuche festzustellen, welche Art von Falte Ist angemessen. Normalerweise löse ich das gesamte Problem ab und gehe die Implementierung der Faltfunktion durch, die für mein Problem gilt.

Was ich also wissen möchte ist:

• Welche Faustregeln gelten für die Entscheidung, ob nach links oder rechts gefaltet werden soll?
• Wie kann ich angesichts des Problems, mit dem ich konfrontiert bin, schnell entscheiden, welche Art von Falte ich verwenden möchte?

In Scala by Example (PDF) gibt es ein Beispiel für die Verwendung einer Falte zum Schreiben einer Funktion namens Abflachen, die eine Liste von Elementlisten zu einer einzigen Liste zusammenfasst. In diesem Fall ist eine rechte Falte die richtige Wahl (angesichts der Art und Weise, wie die Listen verkettet sind), aber ich musste ein wenig darüber nachdenken, um zu dieser Schlussfolgerung zu gelangen.

Da das Falten eine so häufige Aktion in der (funktionalen) Programmierung ist, möchte ich in der Lage sein, solche Entscheidungen schnell und sicher zu treffen. Also ... irgendwelche Tipps?

Sie können eine Falte in eine Infix-Operator-Notation übertragen (dazwischen schreiben):

Dieses Beispiel falten mit der Akkumulatorfunktion x

fold x [A, B, C, D]

also gleich

A x B x C x D

Jetzt müssen Sie nur noch über die Assoziativität Ihres Operators nachdenken (indem Sie Klammern setzen!).

Wenn Sie einen linksassoziativen Operator haben, setzen Sie die Klammern wie folgt

((A x B) x C) x D

Hier verwenden Sie eine linke Falte . Beispiel (Pseudocode im Hashkell-Stil)

foldl (-) [1, 2, 3] == (1 - 2) - 3 == 1 - 2 - 3 // - is left-associative

Wenn Ihr Operator rechtsassoziativ ist ( rechte Falte ), werden die Klammern wie folgt gesetzt:

A x (B x (C x D))

Beispiel: Cons-Operator

foldr (:) [] [1, 2, 3] == 1 : (2 : (3 : [])) == 1 : 2 : 3 : [] == [1, 2, 3]

Im Allgemeinen sind arithmetische Operatoren (die meisten Operatoren) linksassoziativ und daher foldlweiter verbreitet. In den anderen Fällen ist die Infixnotation + Klammern sehr nützlich.

Olin Shivers differenzierte sie mit den Worten "foldl ist der grundlegende Listeniterator" und "foldr ist der grundlegende Listenrekursionsoperator". Wenn Sie sich ansehen, wie Foldl funktioniert:

((1 + 2) + 3) + 4

Sie können sehen, wie der Akkumulator (wie in einer rekursiven Iteration) erstellt wird. Im Gegensatz dazu fährt foldr fort:

1 + (2 + (3 + 4))

Hier können Sie die Durchquerung des Basisfalls 4 sehen und von dort aus das Ergebnis aufbauen.

Ich setze also eine Faustregel auf: Wenn es wie eine Listeniteration aussieht, die einfach in schwanzrekursiver Form zu schreiben wäre, ist foldl der richtige Weg.

Aber dies wird wahrscheinlich am deutlichsten an der Assoziativität der von Ihnen verwendeten Operatoren ersichtlich. Wenn sie linksassoziativ sind, verwenden Sie foldl. Wenn sie rechtsassoziativ sind, verwenden Sie foldr.

Andere Poster haben gute Antworten gegeben und ich werde nicht wiederholen, was sie bereits gesagt haben. Da Sie in Ihrer Frage ein Scala-Beispiel angegeben haben, gebe ich ein Scala-spezifisches Beispiel. Wie Tricks bereits sagte, muss ein foldRightStapelrahmen beibehalten n-1werden, wobei ndie Länge Ihrer Liste und dies leicht zu einem Stapelüberlauf führen kann - und nicht einmal die Schwanzrekursion könnte Sie davor bewahren.

A List(1,2,3).foldRight(0)(_ + _)würde sich reduzieren auf:

1 + List(2,3).foldRight(0)(_ + _)        // first stack frame
    2 + List(3).foldRight(0)(_ + _)      // second stack frame
        3 + 0                            // third stack frame 
// (I don't remember if the JVM allocates space 
// on the stack for the third frame as well)

während List(1,2,3).foldLeft(0)(_ + _)würde sich reduzieren auf:

(((0 + 1) + 2) + 3)

die iterativ berechnet werden kann, wie bei der Implementierung vonList .

In einer streng bewerteten Sprache wie Scala foldRightkann a den Stapel für große Listen leicht in die Luft jagen, während a dies foldLeftnicht tut.

Beispiel:

scala> List.range(1, 10000).foldLeft(0)(_ + _)
res1: Int = 49995000

scala> List.range(1, 10000).foldRight(0)(_ + _)
java.lang.StackOverflowError
        at scala.List.foldRight(List.scala:1081)
        at scala.List.foldRight(List.scala:1081)
        at scala.List.foldRight(List.scala:1081)
        at scala.List.foldRight(List.scala:1081)
        at scala.List.foldRight(List.scala:1081)
        at scala.List.foldRight(List.scala:1081)
        at scala.List.foldRight(List.scala:1081)
        at scala.List.foldRight(List.scala:1081)
        at scala.List.foldRig...

Meine Faustregel lautet daher: Für Operatoren, die keine bestimmte Assoziativität haben, verwenden Sie immer foldLeft, zumindest in Scala. Andernfalls gehen Sie mit anderen Ratschlägen in den Antworten;).

Es ist auch erwähnenswert (und mir ist klar, dass dies ein wenig offensichtlich ist), dass im Fall eines kommutativen Operators die beiden ziemlich gleichwertig sind. In dieser Situation könnte ein Foldl die bessere Wahl sein:

foldl: (((1 + 2) + 3) + 4)kann jede Operation berechnen und den akkumulierten Wert übertragen

foldr: Muss (1 + (2 + (3 + 4)))ein Stapelrahmen für 1 + ?und 2 + ?vor der Berechnung geöffnet werden 3 + 4, dann muss er zurückgehen und die Berechnung für jeden durchführen.

Ich bin nicht genug Experte für funktionale Sprachen oder Compiler-Optimierungen, um zu sagen, ob dies tatsächlich einen Unterschied macht, aber es scheint auf jeden Fall sauberer, ein Foldl mit kommutativen Operatoren zu verwenden.