Aprender Rust Iteradores

Los iteradores son uno de los mecanismos más poderosos y expresivos de Rust, permitiendo procesar colecciones y secuencias de datos de forma declarativa y eficiente. A diferencia de los bucles imperativos, los iteradores de Rust utilizan evaluación perezosa: no ejecutan ningún cálculo hasta que un consumidor los materializa.

El trait Iterator

El trait Iterator define la interfaz fundamental de todos los iteradores en Rust. Solo requiere implementar el método next(), que devuelve Some(elemento) mientras haya datos disponibles y None cuando el iterador se agota. Sobre esta base, la librería estándar proporciona más de 70 métodos adicionales con implementaciones por defecto.

Adaptadores: transformar sin ejecutar

Los adaptadores crean nuevos iteradores a partir de otros sin ejecutar ningún cálculo. Los más usados son map (transformar cada elemento), filter (retener elementos que cumplen un predicado), flat_map (aplanar iteradores de iteradores), enumerate (añadir índice), zip (combinar dos iteradores), take y skip (limitar o saltar elementos), y chain (concatenar iteradores).

let resultado: Vec<i32> = (1..=10)
    .filter(|x| x % 2 == 0)
    .map(|x| x * x)
    .collect();
// [4, 16, 36, 64, 100]

Consumidores: materializar resultados

Los consumidores evalúan la cadena de adaptadores y producen un valor final. Los más importantes son collect (materializar en una colección), fold y reduce (acumular en un valor), sum y product, count, min, max, any, all, find y position.

Iteradores personalizados

Implementar el trait Iterator para tus propios tipos te permite crear fuentes de datos infinitas o lógica de iteración personalizada:

struct Fibonacci { a: u64, b: u64 }

impl Iterator for Fibonacci {
    type Item = u64;
    fn next(&mut self) -> Option<Self::Item> {
        let siguiente = self.a + self.b;
        self.a = self.b;
        self.b = siguiente;
        Some(self.a)
    }
}

Evaluación perezosa: eficiencia sin esfuerzo

Los adaptadores no ejecutan nada hasta que un consumidor los solicita. Esto permite construir pipelines sobre iteradores potencialmente infinitos sin consumir memoria infinita, y al mismo tiempo permite al compilador optimizar la cadena completa en un único bucle eficiente.