Translate

domingo, 5 de octubre de 2025

fold en Elm: Reducción de Listas Paso a Paso


En programación funcional, fold (también conocido como reducción) es una técnica para recorrer una lista y acumular un resultado.

En Elm tenemos dos variantes principales:

List.foldl → recorre la lista de izquierda a derecha.

List.foldr → recorre la lista de derecha a izquierda.


Ambos reciben:

  1. Una función acumuladora.
  2. Un valor inicial.
  3. La lista a recorrer.

Y devuelven un único valor.


Veamos un ejemplo:


suma : List Int -> Int

suma lista =

    List.foldl (\x acc -> x + acc) 0 lista

-- suma [1,2,3,4] == 10


Aquí:

  • (\x acc -> x + acc) es la función acumuladora.
  • 0 es el valor inicial.
  • lista es la lista que recorremos.


Otro ejemplo:


concatenar : List String -> String

concatenar palabras =

    List.foldl (\palabra acc -> palabra ++ " " ++ acc) "" palabras


-- concatenar ["Hola", "mundo"] == "Hola mundo "

Ojo: el orden importa. Si usás `foldr`, el resultado cambia:


List.foldr (\palabra acc -> palabra ++ " " ++ acc) "" ["Hola", "mundo"]

-- "Hola mundo "


En este caso no hay diferencia visible, pero con listas grandes o con operaciones no conmutativas sí la hay.


Otro ejemplo: Calcular el producto (foldl vs foldr)


producto : List Int -> Int

producto =

    List.foldl (\x acc -> x * acc) 1

-- producto [1,2,3,4] == 24


Con foldr se obtiene el mismo resultado porque la multiplicación es conmutativa.


Veamos el orden de evaluación:

foldl (izquierda a derecha):


  foldl f acc [1,2,3]

  == f 3 (f 2 (f 1 acc))


foldr (derecha a izquierda):


  foldr f acc [1,2,3]

  == f 1 (f 2 (f 3 acc))


Esto puede cambiar el resultado cuando la operación no es conmutativa, o puede impactar en la performance con listas grandes.


Veamos otro ejemplo: 


invertir : List a -> List a

invertir lista =

    List.foldl (\x acc -> x :: acc) [] lista


-- invertir [1,2,3] == [3,2,1]


En Elm, fold es una herramienta poderosa para:

  • Reducir listas a un único valor.
  • Evitar bucles explícitos.
  • Expresar cálculos de manera declarativa.


Usá foldl cuando quieras acumular de izquierda a derecha (más común y eficiente).

Usá foldr cuando necesites preservar el orden de construcción en estructuras recursivas.