En programación imperativa, normalmente tenemos un código que tiene el siguiente aspecto:

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

Sin embargo, observe lo siguiente sobre el bucle for:

• Cada iteración tiene un propósito específico, que es agregar uno al elemento actual.
• Sin embargo, cada iteración no tiene restricciones sobre qué elemento puede operar.
• Operar con xs[i 2] y rs[i 3] no alteraría fundamentalmente la estructura del código que tenemos, y al mismo tiempo haría que el resultado final fuera incorrecto.

Compare cómo se haría la misma tarea en F#:

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

Ahora considere lo siguiente:

• Tenemos una lista como argumento de función.
• Una lista en lenguajes funcionales es una lista enlazada.
• Las operaciones eficientes y estándar en listas enlazadas son:
  • Separando la cabeza x de su cola xs
  • Haciendo algo en la cabeza x
  • Comparando la lista pasada como parámetro con la lista vacía []

Dadas estas restricciones, agregar 1 a cualquier elemento y que no esté al principio de la lista alteraría significativamente la estructura de nuestra función.

Ahora compara cómo avanza el cómputo en ambos estilos:

• En el estilo funcional, creamos un nuevo alcance con nuevos valores, lo que implica realizar una llamada recursiva en el ejemplo anterior.
• En el estilo imperativo, mutamos un valor existente sin cambiar el alcance.

En estilo funcional, combinar ambos ámbitos con el progreso computacional tiene las siguientes consecuencias:

• Evitamos la mutación.
• El flujo de ejecución es explícito.
• La estructura que estamos tratando queda clara.