Iterator: map y filter
Los iteradores de Nyx son cadenas perezosas de transformaciones. Llamar .iter() sobre un array crea un iterador, .filter(pred) conserva solo los elementos que satisfacen un predicado, .map(f) transforma cada elemento, y .collect() materializa el resultado en un nuevo array.
Código
// Iterators: filter + map + collect en cadena
fn is_even(x: int) -> bool {
return x % 2 == 0
}
fn double(x: int) -> int {
return x * 2
}
fn square(x: int) -> int {
return x * x
}
fn main() -> int {
let nums: Array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// Filtrar pares y duplicarlos
let result: Array = nums.iter().filter(is_even).map(double).collect()
print("pares duplicados: " + int_to_string(result.length()) + " elementos")
let r0: int = result[0]
let r4: int = result[4]
print("primero: " + int_to_string(r0)) // 4 (2*2)
print("ultimo: " + int_to_string(r4)) // 20 (10*2)
// Solo map: elevar al cuadrado todos
let squares: Array = nums.iter().map(square).collect()
print("cuadrados: " + int_to_string(squares.length()) + " elementos")
let s0: int = squares[0]
let s9: int = squares[9]
print("1^2 = " + int_to_string(s0))
print("10^2 = " + int_to_string(s9))
// Filtrar, mapear y tomar los primeros 3
let top3: Array = nums.iter().filter(is_even).map(double).take(3).collect()
print("top3 pares*2:")
let t0: int = top3[0]
let t1: int = top3[1]
let t2: int = top3[2]
print(int_to_string(t0) + " " + int_to_string(t1) + " " + int_to_string(t2))
return 0
}Salida
pares duplicados: 5 elementos primero: 4 ultimo: 20 cuadrados: 10 elementos 1^2 = 1 10^2 = 100 top3 pares*2: 4 8 12
Explicación
Los pipelines de iteradores en Nyx siguen un patrón consistente: empiezan con .iter(), encadenan cero o más adaptadores intermedios (filter, map, take, skip, etc.), y terminan con un consumidor (collect, fold, for_each). Cada adaptador es perezoso — ningún elemento se procesa hasta que el consumidor impulsa el pipeline. Esto evita alocar arrays intermedios en cada paso.
El primer pipeline, nums.iter().filter(is_even).map(double).collect(), recorre los 10 números: filter deja pasar solo los 5 pares (2, 4, 6, 8, 10), y luego map duplica cada uno, produciendo [4, 8, 12, 16, 20]. Las funciones pasadas a filter y map son funciones de nivel superior nombradas aquí, pero las closures funcionan igual de bien.
Agregar .take(3) a la cadena detiene el pipeline después de recolectar los primeros tres resultados, así que el tercer ejemplo produce [4, 8, 12] sin procesar los elementos restantes. Esta composabilidad — combinar filter, map, take y otros adaptadores en cualquier orden — es la fortaleza central del diseño de iteradores de Nyx.