En programmation impérative, nous avons généralement du code qui ressemble à ceci :

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

Cependant, notez ce qui suit à propos de la boucle for :

• Chaque itération a un objectif spécifique, qui est d'en ajouter une à l'élément actuel.
• Cependant, chaque itération n'a aucune contrainte sur l'élément qu'elle peut opérer.
• Fonctionner avec xs[i 2] et rs[i 3] ne modifierait pas fondamentalement la structure du code que nous avons, tout en rendant le résultat final incorrect.

Comparez comment la même tâche serait effectuée en F# :

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

Considérez maintenant ce qui suit :

• Nous avons une liste comme argument de fonction.
• Une liste dans les langages fonctionnels est une liste chaînée.
• Les opérations efficaces et standards sur les listes chaînées sont :
  • Séparer la tête x de sa queue xs
  • Faire quelque chose à la tête x
  • Comparaison de la liste passée en paramètre avec la liste vide []

Compte tenu de ces restrictions, ajouter 1 à tout élément y qui ne se trouve pas en tête de liste modifierait considérablement la structure de notre fonction.

Comparez maintenant la progression du calcul dans les deux styles :

• Dans le style fonctionnel, nous créons une nouvelle portée avec de nouvelles valeurs, ce qui implique de faire un appel récursif dans l'exemple ci-dessus.
• Dans le style impératif, nous modifions une valeur existante sans changer la portée.

Dans un style fonctionnel, marier les deux portées avec les progrès informatiques a les conséquences suivantes :

• Nous évitons les mutations.
• Le flux d'exécution est explicite.
• La structure à laquelle nous avons affaire devient claire.