Qué es un closure: una función que recuerda su entorno

Una fn es una isla: solo ve sus argumentos y las constantes globales; el resto del programa no existe para ella. Un closure rompe esa clausura. Es una función anónima que puede mirar hacia afuera y capturar las variables del ámbito donde nace, arrastrándolas consigo como equipaje. Por eso let y = 10; let sumar = |x| x + y; compila y una fn equivalente no: el closure no es solo su cuerpo, es su cuerpo más el fragmento de entorno que atrapó. Entender qué captura, y cómo, es entender qué distingue de verdad a un closure de una función.

Una función que ve hacia afuera

Una función ordinaria no puede leer las variables locales de quien la rodea. Este código no compila:

fn main() {
    let y = 10;
    fn sumar(x: i32) -> i32 { x + y }  // ERROR: `y` no existe para esta fn
}

Un closure sí. Se escribe con barras verticales que encierran los parámetros, seguidas del cuerpo:

fn main() {
    let y = 10;
    let sumar = |x| x + y;   // captura `y` del entorno
    println!("{}", sumar(5)); // 15
}

La sintaxis tiene grados de detalle. El cuerpo puede ser una expresión suelta o un bloque, y los tipos son opcionales porque casi siempre se infieren del uso:

let a = |x| x + 1;                       // tipos inferidos
let b = |x: i32| -> i32 { x + 1 };       // tipos explicitos, cuerpo en bloque
let c = || println!("sin parametros");   // cero parametros

Un closure sin capturas —como |x| x + 1— es casi una fn; su interés aparece en cuanto toca una variable de fuera, porque entonces debe llevársela consigo.

Capturar: la parte que “cierra”

El nombre viene de cerrar sobre (to close over) el entorno. Cuando el compilador ve un closure, examina su cuerpo, detecta las variables libres —las que no son parámetros ni locales del propio closure— y las captura. Solo entran las que el cuerpo realmente usa: mencionar y lo captura; no mencionarlo, no.

Bajo el capó, un closure es una struct anónima que el compilador genera: un campo por cada variable capturada, más una implementación de los traits Fn que hace invocable a ese valor. Este desazúcar es conceptual, pero fiel:

let y = 10;
let sumar = |x| x + y;

// El compilador fabrica, aproximadamente, esto:
struct SumarAnon<'a> { y: &'a i32 }   // captura y por referencia
// e implementa Fn(i32) -> i32 llamando a  self.y + x

Esa es la revelación de fondo: un closure es un dato. Ocupa espacio (el de sus capturas), se puede mover, guardar en una struct o pasar a otra función. Uno sin capturas ocupa cero bytes; uno que atrapa un Vec es tan grande como el manejador de ese Vec.

Las tres formas de captura

Aquí está el corazón del asunto. El compilador no captura de una única manera: elige, para cada variable, la forma menos restrictiva que el cuerpo tolere. Hay tres, en orden creciente de exigencia.

Cada forma se ve en código. Si solo lees, basta una referencia compartida:

let saludo = String::from("hola");
let imprime = || println!("{saludo}");  // captura &saludo: solo lee
imprime();
println!("{saludo}");                    // saludo sigue disponible

Si mutas, la captura sube a &mut, y el closure debe ser mut:

let mut cuenta = 0;
let mut incrementa = || cuenta += 1;    // captura &mut cuenta
incrementa();
incrementa();
println!("{cuenta}");                    // 2

Y si el cuerpo exige posesión —por ejemplo, moviendo el valor a otro lugar—, la captura es por valor y el original deja de estar disponible:

let datos = vec![1, 2, 3];
let consume = || { let propio = datos; propio.len() }; // mueve datos adentro
// println!("{datos:?}");  // ERROR: datos ya fue movido al closure

flowchart TB
body[El compilador analiza el cuerpo del closure] --> q1[El cuerpo solo lee la variable]
q1 -->|si| ref[Captura por referencia compartida]
q1 -->|no| q2[El cuerpo la muta]
q2 -->|si| mut[Captura por referencia mutable]
q2 -->|no| val[Captura por valor]
style ref fill:#a6e3a1,color:#11111b
style mut fill:#89b4fa,color:#11111b
style val fill:#fab387,color:#11111b

La regla “la menos restrictiva posible” no es un capricho: maximiza lo que puedes seguir haciendo con las variables originales. Capturar por referencia deja el valor donde estaba; capturar por valor lo consume. Rust prefiere lo primero salvo que el cuerpo obligue a lo segundo. En la próxima lección veremos que esta elección de captura determina, además, qué traits (Fn, FnMut, FnOnce) implementa el closure.