Adaptadores fundamentales: map, filter, fold, sum y zip

Con next y la pereza ya tienes la mecánica; ahora llega el vocabulario. Casi cualquier manipulación de una secuencia se expresa combinando cinco operaciones: map para transformar, filter para seleccionar, zip para emparejar, y fold para reducirlo todo a un único valor, del que sum es apenas el caso más frecuente. Aprenderlas no es memorizar una API: es adquirir una gramática con la que describir cálculos sobre colecciones sin escribir un solo bucle, y descubrir que bajo esa variedad late una sola operación —acumular— de la que las demás son variaciones.

map: transformar cada elemento

map aplica una clausura a cada valor y produce un iterador con los resultados. Es la transformación uno a uno: la longitud no cambia, el tipo puede cambiar por completo.

let nombres = ["ada", "alan", "grace"];
let largos: Vec<usize> = nombres.iter().map(|s| s.len()).collect();
// [3, 4, 5]: de &str a usize

La clausura recibe cada Item y devuelve lo que quieras; map se limita a envolver esa promesa, perezosamente, sin ejecutarla hasta el consumo. Cambiar el tipo de salida es lo normal, no la excepción: de un texto a su longitud, de un registro a un campo, de un error a otro.

filter: quedarse con algunos

filter conserva solo los elementos que satisfacen un predicado. La secuencia se acorta; el tipo se mantiene.

let pares: Vec<i32> = (1..=10).filter(|n| n % 2 == 0).collect();
// [2, 4, 6, 8, 10]

Un matiz técnico revelador: el predicado recibe una referencia al elemento, &Self::Item. Por eso arriba n es &i32 y n % 2 funciona por deref automático. La razón es de propiedad: filter solo inspecciona para decidir, no consume, así que presta el valor en lugar de moverlo, y quien pase el filtro sigue su camino intacto.

fold, sum y product: el acumulador universal

fold es la operación de la que descienden casi todas las demás. Recibe un valor inicial y una clausura de dos argumentos —el acumulador y el elemento actual—, y recorre la secuencia entera fusionando cada elemento en el acumulador:

let suma = (1..=5).fold(0, |acc, x| acc + x);        // 15
let producto = (1..=5).fold(1, |acc, x| acc * x);    // 120
let concat = ["a", "b", "c"]
    .iter()
    .fold(String::new(), |mut s, x| { s.push_str(x); s });  // "abc"

Lee la firma mental: partes de init, y por cada elemento sustituyes el acumulador por el resultado de la clausura. Al agotarse la secuencia, el acumulador final es el resultado. fold no es perezoso: es un consumidor que recorre todo y devuelve un valor. Y fíjate en el poder: con solo cambiar el inicial y la clausura, fold suma, multiplica, concatena, cuenta o construye cualquier estructura.

Sumar y multiplicar son tan comunes que tienen consumidores propios, sum y product, más legibles que el fold equivalente:

let total: i32 = (1..=100).sum();          // 5050
let fact: u64 = (1..=10).product();        // 3628800

Necesitan una anotación de tipo (: i32) porque sum es genérico sobre a qué tipo sumar. Conceptualmente, sum() es fold(0, |a, b| a + b) y product() es fold(1, |a, b| a * b): el mismo motor de acumulación, con nombre propio.

zip: caminar dos a la vez

zip entrelaza dos iteradores en uno de pares, avanzando ambos en paralelo y produciendo tuplas (a, b). Se detiene en cuanto el más corto se agota:

let nombres = ["Ada", "Alan", "Grace"];
let edades = [36, 41, 45];
let fichas: Vec<(&str, i32)> = nombres
    .iter()
    .copied()
    .zip(edades.iter().copied())
    .collect();
// [("Ada", 36), ("Alan", 41), ("Grace", 45)]

Como los adaptadores se componen, zip brilla junto a map: emparejar y luego combinar cada par es un patrón diario, por ejemplo para el producto escalar de dos vectores.

let a = [1, 2, 3];
let b = [4, 5, 6];
let punto: i32 = a.iter().zip(b.iter()).map(|(x, y)| x * y).sum();
// 1*4 + 2*5 + 3*6 = 32

flowchart LR
src[Rango 1 a 5] --> mapa[map duplica cada valor]
mapa --> filtro[filter deja los mayores que cuatro]
filtro --> fold[fold acumula en un total]
fold --> res[Un unico valor final]
style src fill:#a6e3a1,color:#11111b
style fold fill:#89b4fa,color:#11111b
style res fill:#cba6f7,color:#11111b