Implementar el trait Iterator en Rust para tus propios tipos

22 de julio de 2026Por Angel Carrero2 min de lectura
Implementar el trait Iterator en Rust para tus propios tipos

Cuando implementas el trait Iterator para un tipo, solo defines un método: next(). A cambio, obtienes gratis más de setenta métodos: map, filter, collect, enumerate, zip, take, fold… Cualquier código que acepte un iterador aceptará el tuyo automáticamente.

Contador básico

struct Contador {
    valor: u32,
    max: u32,
}

impl Contador {
    fn new(max: u32) -> Self {
        Contador { valor: 0, max }
    }
}

impl Iterator for Contador {
    type Item = u32;

    fn next(&mut self) -> Option<u32> {
        if self.valor < self.max {
            self.valor += 1;
            Some(self.valor)
        } else {
            None
        }
    }
}

fn main() {
    let c = Contador::new(5);

    // Todos estos métodos vienen gratis
    let suma: u32 = c.sum();
    println!("Suma 1..5 = {}", suma); // 15

    let dobles: Vec<_> = Contador::new(5).map(|x| x * 2).collect();
    println!("{:?}", dobles); // [2, 4, 6, 8, 10]

    let pares: Vec<_> = Contador::new(10).filter(|x| x % 2 == 0).collect();
    println!("{:?}", pares); // [2, 4, 6, 8, 10]
}

Fibonacci infinito

struct Fibonacci {
    a: u64,
    b: u64,
}

impl Fibonacci {
    fn new() -> Self {
        Fibonacci { a: 0, b: 1 }
    }
}

impl Iterator for Fibonacci {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        let siguiente = self.a + self.b;
        self.a = self.b;
        self.b = siguiente;
        Some(self.a) // infinito: nunca devuelve None
    }
}

fn main() {
    // take() limita el iterador infinito
    let fib: Vec<u64> = Fibonacci::new().take(10).collect();
    println!("{:?}", fib); // [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

    // Primer Fibonacci mayor que 1000
    let grande = Fibonacci::new().find(|&n| n > 1000);
    println!("{:?}", grande); // Some(1597)
}

Árbol binario con recorrido en orden

enum Arbol {
    Vacio,
    Nodo { valor: i32, izq: Box<Arbol>, der: Box<Arbol> },
}

struct RecorridoEnOrden {
    pila: Vec<i32>,
}

impl RecorridoEnOrden {
    fn new(arbol: &Arbol) -> Self {
        let mut pila = Vec::new();
        Self::recopilar(arbol, &mut pila);
        RecorridoEnOrden { pila }
    }

    fn recopilar(arbol: &Arbol, pila: &mut Vec<i32>) {
        if let Arbol::Nodo { valor, izq, der } = arbol {
            Self::recopilar(izq, pila);
            pila.push(*valor);
            Self::recopilar(der, pila);
        }
    }
}

impl Iterator for RecorridoEnOrden {
    type Item = i32;

    fn next(&mut self) -> Option<i32> {
        if self.pila.is_empty() { None } else { Some(self.pila.remove(0)) }
    }
}

IntoIterator: para usar en for loops

struct Rango {
    inicio: i32,
    fin: i32,
}

impl IntoIterator for Rango {
    type Item = i32;
    type IntoIter = std::ops::Range<i32>;

    fn into_iter(self) -> Self::IntoIter {
        self.inicio..self.fin
    }
}

fn main() {
    let r = Rango { inicio: 1, fin: 6 };
    for n in r {
        print!("{} ", n); // 1 2 3 4 5
    }
}

Resumen

  • Implementa solo next() -> Option<Item> y obtienes más de 70 métodos gratis.
  • Los iteradores infinitos (que nunca devuelven None) se limitan con take().
  • Implementa IntoIterator para que tu tipo funcione directamente en bucles for.
  • El trait Iterator es la abstracción más reutilizable del ecosistema Rust.

El siguiente artículo cubre Box<T>: cuándo necesitas asignar en el heap, cómo usar tipos recursivos y el dispatch dinámico con Box<dyn Trait>.

Sigue leyendo