fold es el consumidor de iteradores de propósito general que reduce una secuencia a un único valor. Toma un acumulador inicial y una función de dos argumentos, aplica la función a cada elemento y al acumulador en curso, y retorna el resultado acumulado final.
// fold: reducir un iterator a un valor acumulando con una función fn add(acc: int, x: int) -> int { return acc + x } fn multiply(acc: int, x: int) -> int { return acc * x } fn max_val(acc: int, x: int) -> int { if x > acc { return x } return acc } fn is_even(x: int) -> bool { return x % 2 == 0 } fn main() -> int { let nums: Array = [1, 2, 3, 4, 5] // Suma con fold — equivale a un loop manual con acumulador let suma: int = nums.iter().fold(0, add) print("suma(1..5) = " + int_to_string(suma)) // 15 // Producto con fold let producto: int = nums.iter().fold(1, multiply) print("producto(1..5) = " + int_to_string(producto)) // 120 // Máximo con fold let maximo: int = nums.iter().fold(0, max_val) print("max(1..5) = " + int_to_string(maximo)) // 5 // Sumar solo los pares con filter + fold let nums2: Array = [10, 3, 8, 7, 2, 6] let suma_pares: int = nums2.iter().filter(is_even).fold(0, add) print("suma pares = " + int_to_string(suma_pares)) // 26 (10+8+2+6) // fold con valor inicial distinto de cero let nums3: Array = [1, 2, 3] let con_offset: int = nums3.iter().fold(100, add) print("100 + sum(1,2,3) = " + int_to_string(con_offset)) // 106 return 0 }
suma(1..5) = 15 producto(1..5) = 120 max(1..5) = 5 suma pares = 26 100 + sum(1,2,3) = 106
Cómo funciona
fold(init, f) es equivalente a escribir manualmente un loop con una variable acumuladora: comienza con acc = init y para cada elemento x calcula acc = f(acc, x), retornando el acc final. La elección del valor inicial es importante: 0 es el elemento neutro para la suma (sumar cero no cambia nada), mientras que 1 es el elemento neutro para la multiplicación. Elegir el valor inicial incorrecto da resultados incorrectos.
La función acumuladora max_val selecciona el mayor entre el acumulador actual y el elemento entrante, así que hacer fold sobre un array con 0 como inicio encuentra el máximo. Esto funciona correctamente aquí porque todos los valores son positivos; para arrays que puedan contener negativos, el valor inicial debería fijarse al entero mínimo posible.
Combinar filter y fold en un solo pipeline — como en el ejemplo de suma de pares — es idiomático en Nyx: filter reduce el flujo, y luego fold lo reduce a un valor, sin alocar ningún array intermedio. Muchas operaciones clásicas (sum, product, count, any, all) son casos especiales de fold y pueden expresarse de esta manera.