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:
- Una función acumuladora.
- Un valor inicial.
- 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.