Adaptadores potentes: componer flujos de datos

Un iterador en Rust es una descripción perezosa de un cálculo, no el cálculo mismo. Cada adaptador —map, filter, zip— envuelve al anterior y no consume nada hasta que un consumidor final tira de la cadena. Esa pereza es lo que permite componer decenas de transformaciones sin materializar colecciones intermedias: el pipeline entero se funde, al compilar, en un solo recorrido. Este nivel arranca con los adaptadores que convierten esa composición en un lenguaje expresivo para describir flujos de datos.

Emparejar, concatenar, indexar

zip toma dos iteradores y produce uno de pares: en cada paso avanza ambos y emite una tupla (a, b). Se detiene en cuanto el más corto se agota, lo que lo hace seguro frente a longitudes distintas y, de paso, útil con fuentes infinitas.

let nombres = ["Ana", "Beto", "Cira"];
let edades = [30, 25, 41];

let pares: Vec<(&str, i32)> = nombres.iter().copied().zip(edades).collect();
assert_eq!(pares[1], ("Beto", 25));

enumerate es un caso tan común que tiene nombre propio: adjunta a cada elemento su índice usize, empezando en cero. Conceptualmente es zip contra el rango infinito 0.., pero se lee mejor.

for (i, c) in "rust".chars().enumerate() {
    println!("{i}: {c}"); // 0: r, 1: u, 2: s, 3: t
}

chain hace lo contrario a zip: en vez de recorrer dos fuentes a la par, las concatena, agotando la primera y siguiendo con la segunda. Ambas deben producir el mismo Item.

let a = [1, 2];
let b = [3, 4];
let todo: Vec<i32> = a.iter().chain(b.iter()).copied().collect();
assert_eq!(todo, [1, 2, 3, 4]);

Recortar y aplanar

take(n) trunca la cadena a los primeros n elementos; skip(n) descarta esos primeros n y deja pasar el resto. Su verdadero poder aparece con fuentes ilimitadas: take es la tijera que hace finito un flujo infinito.

let primeros: Vec<u64> = (1..).take(5).collect(); // 1, 2, 3, 4, 5
let saltados: Vec<i32> = (0..10).skip(7).collect(); // 7, 8, 9

Cuando el corte no depende de una cuenta sino de una condición, están take_while y skip_while, que actúan mientras el predicado se cumple.

let subida: Vec<i32> = [1, 3, 8, 2, 9].iter().copied().take_while(|&x| x < 5).collect();
assert_eq!(subida, [1, 3]); // se detiene en el primer 8, no filtra el resto

flat_map es map seguido de aplanado: cada elemento se transforma en otro iterador, y todos se concatenan en un flujo único. Es la herramienta para expandir una estructura anidada en una plana.

let frases = ["hola mundo", "adios rust"];
let palabras: Vec<&str> = frases.iter().flat_map(|f| f.split_whitespace()).collect();
assert_eq!(palabras, ["hola", "mundo", "adios", "rust"]);

Equivale a .map(...).flatten(), pero expresa en un solo verbo la intención de expandir y unir.

Estado y ventanas

scan es un map con memoria: mantiene un estado mutable entre elementos y, en cada paso, decide qué emitir. Su clausura recibe &mut estado y el elemento, y devuelve un Option: Some(y) emite y, None corta la iteración. El acumulado clásico —sumas parciales— es su ejemplo canónico.

let parciales: Vec<i32> = [1, 2, 3, 4]
    .iter()
    .scan(0, |acc, &x| {
        *acc += x;
        Some(*acc)
    })
    .collect();
assert_eq!(parciales, [1, 3, 6, 10]);

Cierran el nivel dos métodos que no son adaptadores de Iterator, sino de los slices [T]: windows y chunks. windows(n) produce sub-slices solapados de longitud n, deslizando de uno en uno; chunks(n) los produce disjuntos, sin solape. Cada elemento es un &[T].

let v = [1, 2, 3, 4];
let w: Vec<&[i32]> = v.windows(2).collect(); // [1,2], [2,3], [3,4]
let c: Vec<&[i32]> = v.chunks(2).collect();  // [1,2], [3,4]
assert_eq!(w.len(), 3);
assert_eq!(c.len(), 2);

Que vivan en el slice y no en Iterator no es capricho: solapar ventanas exige poder mirar atrás sobre un buffer contiguo, algo que un iterador genérico —de un solo paso hacia adelante— no puede garantizar. La distinción es una lección de diseño, no un detalle.

flowchart LR
src[Fuente iteradora] --> zip[zip empareja con otra fuente]
zip --> enu[enumerate anade indice]
enu --> fil[filter o map transforma]
fil --> tk[take corta a n elementos]
tk --> out[Consumidor collect o for]
style src fill:#cba6f7,color:#11111b
style fil fill:#89b4fa,color:#11111b
style out fill:#a6e3a1,color:#11111b