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
- Usando solo métodos de iterador, calcula la suma de los cuadrados de los números impares menores que 100.
- Escribe
fn group_by_len(words: &[&str]) -> HashMap<usize, Vec<String>>confoldo con un buclefory la API entry. - Implementa un iterador
Countdown(u32)que produzcan, n-1, …, 1, y después usa adaptadores (sin.rev()) para imprimir solo los múltiplos de 3. - 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.¿Qué hace
v.iter().map(|x| x * 2);por sí solo?2.Una clausura que al llamarse mueve fuera de sí un
Stringcapturado, ¿qué trait implementa?3.¿Qué hace la palabra clave
moveen una clausura?