FerrousPath

Nivel 2 · Practicante· Lección 4 de 8 · 30 min

Clausuras e iteradores

Funciones anónimas que capturan su entorno, los tres traits Fn y cadenas de iteradores perezosos que se compilan a bucles ajustados.

Clausuras

Una clausura (closure) es una función anónima que puede usar variables del ámbito donde se define.

fn main() {
    let factor = 3;
    let scale = |x: i32| x * factor; // captura `factor` por referencia
    println!("{}", scale(14));

    let mut log = Vec::new();
    let mut record = |msg: &str| log.push(msg.to_string()); // captura `log` de forma mutable
    record("start");
    record("stop");
    println!("{log:?}");
}

Los tipos de los parámetros y del retorno normalmente se infieren. Cada clausura tiene su propio tipo, único e imposible de nombrar, y por eso las clausuras se reciben mediante genéricos.

Fn, FnMut, FnOnce

El compilador captura cada variable de la forma menos restrictiva que permita el cuerpo, y eso determina qué traits implementa la clausura:

Trait La clausura… Se puede llamar
Fn solo lee sus capturas muchas veces, incluso de forma concurrente
FnMut modifica sus capturas muchas veces, necesita &mut
FnOnce consume sus capturas una vez

Toda Fn es también FnMut, y toda FnMut es también FnOnce. Así que al escribir una función que recibe una clausura, pide el trait más débil que puedas: FnOnce si la llamas una vez, FnMut si la llamas varias, y Fn solo si necesitas llamadas compartidas.

fn apply_twice<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
    f(f(x))
}

fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n // `move`: toma la propiedad de n para que la clausura pueda sobrevivir a esta función
}

fn make_counter() -> impl FnMut() -> u32 {
    let mut count = 0;
    move || {
        count += 1;
        count
    }
}

fn main() {
    println!("{}", apply_twice(|x| x * x, 3));
    let add5 = make_adder(5);
    println!("{}", add5(10));
    let mut next = make_counter();
    println!("{} {} {}", next(), next(), next());

    let name = String::from("Ferris");
    let consume = move || name; // devuelve el String capturado: FnOnce
    println!("{}", consume());
    // consume(); // ❌ ya se llamó una vez
}

El trait Iterator

trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
    // …más unos 75 métodos proporcionados, construidos sobre next()
}

Implementa un método y recibes todo lo demás:

struct Fibonacci { a: u64, b: u64 }

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

fn main() {
    let fib = Fibonacci { a: 0, b: 1 };
    let evens: Vec<u64> = fib
        .filter(|n| n % 2 == 0)
        .take_while(|&n| n < 1000)
        .collect();
    println!("{evens:?}");
}

Ese iterador es infinito, y no pasa nada, porque los iteradores son perezosos: los adaptadores describen el trabajo, y no ocurre nada hasta que un consumidor pide elementos.

Tres formas de iterar una colección

Llamada Produce La colección después
v.iter() o for x in &v &T se puede seguir usando
v.iter_mut() o for x in &mut v &mut T se puede seguir usando
v.into_iter() o for x in v T queda consumida

Un vocabulario de trabajo

fn main() {
    let words = vec!["apple", "bob", "cherry", "dad", "elderberry"];

    // Adaptadores: perezosos, devuelven otro iterador.
    let long: Vec<String> = words
        .iter()
        .filter(|w| w.len() > 3)
        .map(|w| w.to_uppercase())
        .collect();
    println!("{long:?}");

    // Consumidores: hacen avanzar el iterador y producen un valor.
    let total: usize = words.iter().map(|w| w.len()).sum();
    let longest = words.iter().max_by_key(|w| w.len());
    let has_palindrome = words.iter().any(|w| w.chars().eq(w.chars().rev()));
    let position = words.iter().position(|&w| w == "cherry");
    println!("{total} {longest:?} {has_palindrome} {position:?}");

    // fold: el acumulador general.
    let sentence = words.iter().fold(String::new(), |mut acc, w| {
        if !acc.is_empty() { acc.push(' '); }
        acc.push_str(w);
        acc
    });
    println!("{sentence}");

    // Combinar iteradores.
    for (i, (a, b)) in words.iter().zip(words.iter().skip(1)).enumerate() {
        println!("{i}: {a} → {b}");
    }
    let nested = vec![vec![1, 2], vec![], vec![3]];
    let flat: Vec<i32> = nested.into_iter().flatten().collect();
    let windows: Vec<i32> = flat.windows(2).map(|w| w[1] - w[0]).collect();
    println!("{flat:?} {windows:?}");
}

collect es genérico respecto a su destino

use std::collections::{BTreeSet, HashMap};

fn main() {
    let pairs = [("one", 1), ("two", 2), ("three", 3)];
    let map: HashMap<_, _> = pairs.into_iter().collect();
    let set: BTreeSet<char> = "mississippi".chars().collect();
    let joined: String = set.iter().collect();
    println!("{} {joined}", map["two"]);

    // Recoger Results: se detiene en el primer error.
    let good: Result<Vec<i32>, _> = ["1", "2", "3"].iter().map(|s| s.parse::<i32>()).collect();
    let bad: Result<Vec<i32>, _> = ["1", "x", "3"].iter().map(|s| s.parse::<i32>()).collect();
    println!("{good:?}\n{bad:?}");
}

Abstracción de coste cero

Una cadena de iteradores es una pila de structs genéricos, cada uno monomorfizado y expandido en línea dentro del siguiente. Tras la optimización, xs.iter().map(f).filter(g).sum() suele compilarse al mismo código máquina que el bucle que habrías escrito a mano, y a veces a uno mejor, porque iterar un slice no necesita comprobaciones de límites. Escribe la cadena que mejor se lea.

Ejercicios

  1. Usando solo métodos de iterador, calcula la suma de los cuadrados de los números impares menores que 100.
  2. Escribe fn group_by_len(words: &[&str]) -> HashMap<usize, Vec<String>> con fold o con un bucle for y la API entry.
  3. Implementa un iterador Countdown(u32) que produzca n, n-1, …, 1, y después usa adaptadores (sin .rev()) para imprimir solo los múltiplos de 3.
  4. Escribe fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C.
Solución del 4
fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
    move |x| g(f(x))
}

fn main() {
    let inc_then_double = compose(|x: i32| x + 1, |x: i32| x * 2);
    println!("{}", inc_then_double(5));
}

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Qué hace v.iter().map(|x| x * 2); por sí solo?

  2. 2.Una clausura que al llamarse mueve fuera de sí un String capturado, ¿qué trait implementa?

  3. 3.¿Qué hace la palabra clave move en una clausura?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?