Bei der imperativen Programmierung haben wir normalerweise Code, der wie folgt aussieht:

func addOneToSlice(xs []int) []int {
  rs := make([]int, len(xs))
  for i, value := range xs {
    rs[i] = value   1
  }
  return rs
}

Beachten Sie jedoch Folgendes zur for-Schleife:

• Jede Iteration hat einen bestimmten Zweck, nämlich das Hinzufügen eines Elements zum aktuellen Element.
• Jeder Iteration unterliegt jedoch keiner Einschränkung hinsichtlich des Elements, das sie ausführen kann.
• Der Betrieb mit xs[i 2] und rs[i 3] würde die Struktur unseres Codes nicht grundlegend verändern, während das Endergebnis falsch wäre.

Vergleichen Sie, wie dieselbe Aufgabe in F# erledigt würde:

let rec addOneToList =
  function
  | [] -> []
  | x :: xs -> x   1 :: addOneToList xs

Bedenken Sie nun Folgendes:

• Wir haben eine Liste als Funktionsargument.
• Eine Liste in funktionalen Sprachen ist eine verknüpfte Liste.
• Die effizienten Standardoperationen für verknüpfte Listen sind:
  • Das Kopf-x von seinem Schwanz-xs trennen
  • Etwas mit dem Kopf machen x
  • Vergleich der als Parameter übergebenen Liste mit der leeren Liste []

Angesichts dieser Einschränkungen würde das Hinzufügen von 1 zu einem beliebigen Element y, das nicht am Anfang der Liste steht, die Struktur unserer Funktion erheblich verändern.

Vergleichen Sie nun, wie die Berechnung in beiden Stilen voranschreitet:

• Im funktionalen Stil erstellen wir einen neuen Bereich mit neuen Werten, was im obigen Beispiel einen rekursiven Aufruf erfordert.
• Im Imperativstil mutieren wir einen vorhandenen Wert, ohne den Geltungsbereich zu ändern.

Im funktionalen Stil hat die Verbindung von Umfang und Rechenfortschritt die folgenden Konsequenzen:

• Wir vermeiden Mutationen.
• Der Ausführungsablauf ist explizit.
• Die Struktur, mit der wir es zu tun haben, wird klar.