Clausuras en Rust
Una clausura en Rust es una función anónima que puede capturar y almacenar variables de su entorno.
Las clausuras permiten acceder a variables fuera del ámbito donde se definen, y pueden moverlas o tomarlas prestadas para que la clausura las use cuando sea necesario.
Las clausuras se usan ampliamente en Rust en ámbitos como la programación funcional, la programación concurrente y la programación dirigida por eventos.
Diferencia entre clausuras y funciones
Tanto las clausuras como las funciones normales pueden encapsular lógica, pero las clausuras añaden una capacidad fundamental: capturar variables del entorno externo. La siguiente tabla enumera las principales diferencias entre ambas:
| Característica | Clausura | Función |
|---|---|---|
| Anonimato | No tiene nombre y normalmente se asigna a una variable | Tiene unfnnombre fijo |
| Captura de entorno | Puede capturar variables externas | No puede capturar variables externas |
| Forma de definición | |parámetros| expresión | fn nombre(parámetros) |
| Inferencia de tipos | Los tipos de los parámetros y del valor de retorno generalmente se pueden omitir | Deben especificarse explícitamente los tipos de los parámetros y del valor de retorno |
| Almacenamiento y transmisión | Puede usarse como variable, parámetro o valor de retorno | También lo admite |
Declaración e invocación de clausuras
La sintaxis básica de una clausura es la siguiente:
let closure_name = |参数列表| 表达式或语句块;
Los parámetros pueden tener anotaciones de tipo u omitirse: el compilador de Rust los infiere según el contexto.
Ejemplo
// Clausura: se omiten las anotaciones de tipo, el compilador lo infiere automáticamente
let add_one = |x| x + 1;
println!("add_one(4) = {}", add_one(4)); // Salida: 5
// Clausura: anotación explícita de los tipos de parámetros y retorno
let multiply = |a: i32, b: i32| -> i32 { a * b };
println!("multiply(3, 7) = {}", multiply(3, 7)); // Salida: 21
// Una clausura de varias líneas requiere llaves
let greet = |name: &str| {
let greeting = format!("Hello, {}!", name);
greeting
};
println!("{}", greet("ejemplo")); // Salida: Hello, ejemplo!
}
La forma de invocar una clausura es exactamente igual que la de una función normal: basta con añadir paréntesis después del nombre de la variable y pasar los argumentos.
Captura de variables externas
La característica más esencial de una clausura es su capacidad de capturar variables de su ámbito. Esta es la diferencia fundamental entre una clausura y una función normal.
Una clausura puede capturar variables externas de tres maneras:
| Método de captura | Semántica de Rust correspondiente | Descripción |
|---|---|---|
| Captura por referencia | Similar a&T | Comportamiento predeterminado: la clausura toma prestada la variable, el exterior aún puede usarla |
| Captura con préstamo mutable | Similar a&mut T | La clausura necesita modificar la variable; la propia clausura debe declararse como `mut`mut |
| Captura por valor | Similar aT | Usamovela palabra clave `move`, que transfiere la propiedad de la variable a la clausura |
Para tipos que implementan el
Copytrait `Copy` (como `i32`),i32、bool),movesolo se copia el valor y la variable externa sigue disponible. Por lo tanto, al demostrar la transferencia de propiedad se debe elegir un tipo como `String`,String、Vecque no seaCopy`Copy`.
Captura por referencia
De forma predeterminada, la clausura toma prestada la variable externa mediante una referencia inmutable. Al terminar el préstamo, el ámbito externo puede seguir usando esa variable.
Ejemplo
let text = String::from("ejemplo");
// La clausura captura `text` por referencia, sin tomar posesión
let print_text = || println!("text = {}", text);
print_text(); // Salida: text = ejemplo
// El préstamo ha terminado, el exterior aún puede usar `text`
println!(Aún se puede usar externamente: {}, text);
}
Captura con préstamo mutable
Si la clausura necesita modificar la variable capturada, Rust la captura mediante una referencia mutable. En este caso, la propia clausura debe declararse como `mut`.mut。
Ejemplo
let mut counter = 0;
// La clausura captura `counter` con `&mut`; la propia clausura también debe declararse como `mut`
let mut inc = || {
counter += 1;
};
inc();
inc();
println!("counter = {}", counter); // Salida: counter = 2
}
Captura por valor (move)
Al añadir la palabra clavemove`move` antes de la clausura, la clausura obtiene la propiedad de las variables capturadas. Después de la transferencia de propiedad, el ámbito externo ya no puede usar esas variables.
Ejemplo
let owned = String::from("EJEMPLO");
// `move` transfiere la propiedad de `owned` a la clausura
let take_owned = move || println!("owned = {}", owned);
take_owned(); // Salida: owned = EJEMPLO
// Si se descomenta la siguiente línea, se producirá un error de compilación: la propiedad de `owned` ya se ha movido a la clausura
// println!("{}", owned);
}
Cuando se necesita pasar la clausura a otro hilo o devolverla fuera del ámbito,move`move` es especialmente útil: garantiza que la clausura tenga la propiedad de los datos necesarios y evita referencias colgantes.
Trait de clausura: Fn / FnMut / FnOnce
El compilador de Rust implementa automáticamente el trait correspondiente para la clausura según la forma en que esta captura las variables. Comprender estos tres traits es clave para usar clausuras como argumentos o valores de retorno de funciones.
| Trait | Método de captura | Número de invocaciones posibles | Escenario típico |
|---|---|---|---|
Fn | Préstamo inmutable (`Fn`)&T) | Múltiples veces | Acceso de solo lectura a las variables capturadas |
FnMut | Préstamo mutable (`FnMut`)&mut T) | Múltiples veces | Necesita modificar las variables capturadas |
FnOnce | Toma de posesión (`FnOnce`)T) | Solo una vez | Consume las variables capturadas; después no se puede volver a invocar |
La relación de herencia entre los tres es:FnSíFnMut`FnMut` es subtrait de `Fn`, y `FnOnce`FnMutSíFnOncees subtrait de `FnMut`. Es decir, una clausura que implementaFn`Fn`, automáticamente también implementa `FnMut` y `FnOnce`.FnMutyFnOnce。
Nota:
moveLa palabra clave `move` solo obliga a tomar posesión, no significa que la clausura deba ser necesariamenteFnOnce`FnOnce`. Si el cuerpo de la clausura no consume el valor capturado, incluso si se añademove`move`, la clausura puede seguir implementandoFn`Fn` (invocable varias veces).
Ejemplo
let name = String::from("ejemplo");
// Clausura Fn: solo lee, no modifica, puede invocarse varias veces
let greet = || println!("Hello, {}!", name);
greet(); // Primera invocación
greet(); // Segunda invocación, sigue funcionando
// Clausura FnMut: necesita modificar la variable capturada
let mut count = 0;
let mut increment = || {
count += 1;
count
};
println!("increment() = {}", increment()); // Salida: 1
println!("increment() = {}", increment()); // Salida: 2
// Clausura FnOnce: consume la variable capturada, solo puede invocarse una vez
let data = String::from("EJEMPLO");
let consume = move || {
let _ = data; // Mueve `data` fuera del entorno de la clausura, consumiéndola
println!("data has been consumed");
};
consume();
// consume(); // Si se descomenta, error de compilación: la clausura FnOnce solo puede invocarse una vez
}
Clausuras como parámetros y valores de retorno
Las clausuras pueden pasarse como argumentos de función y también devolverse como valor de retorno. Estos son los dos usos más comunes de las clausuras en el desarrollo real.
Clausura como parámetro
Al usar una clausura como parámetro, hay que especificar el tipo de trait de la clausura mediante una restricción genérica. En el siguiente ejemplo, el parámetroF`F` está restringido a `Fn(i32) -> i32`,Fn(i32) -> i32lo que significa que recibe un `i32`i32y devuelve un `i32`i32.
Ejemplo
fn apply<F>(val: i32, f: F) -> i32
where
F: Fn(i32) -> i32, // F debe implementar Fn(i32) -> i32
{
f(val)
}
fn main() {
let double = |x| x * 2;
let result = apply(5, double);
println!("Result: {}", result); // Salida: Result: 10
// También se puede pasar una clausura anónima directamente
let result2 = apply(3, |x| x + 100);
println!("Result2: {}", result2); // Salida: Result2: 103
}
Clausura como valor de retorno
Dado que el tipo de una clausura es anónimo, al devolver una clausura se debe usarimpl TraitoBox<dyn Trait>`impl Fn` para describir el tipo de retorno.
Devolver una clausura con `impl Fn`
Cuando el tipo de la clausura devuelta se puede determinar en tiempo de compilación, se usaimpl Fn`impl Fn`, sin necesidad de asignación en el montón.
Ejemplo
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
// Debe usarse `move`, de lo contrario `x` es una referencia local y `x` ya no es válida después de que la clausura se devuelva
move |y| x + y
}
fn main() {
let add_five = make_adder(5);
println!("5 + 3 = {}", add_five(3)); // Salida: 5 + 3 = 8
let add_ten = make_adder(10);
println!("10 + 2 = {}", add_ten(2)); // Salida: 10 + 2 = 12
}
Devolver cierres con Box<dyn Fn>
Cuando necesite elegir dinámicamente diferentes cierres para devolver en tiempo de ejecución, useBox<dyn Fn>Asigna el cierre al montón.
Ejemplo
Box::new(move |y| x + y)
}
fn main() {
let add_ten = make_adder(10);
println!("10 + 2 = {}", add_ten(2)); // Salida: 10 + 2 = 12
}
| Método | Ubicación de asignación | Escenario aplicable |
|---|---|---|
impl Fn | pila | El tipo de cierre se puede determinar en tiempo de compilación, con mejor rendimiento. |
Box<dyn Fn> | montículo | Elegir cierres dinámicamente en tiempo de ejecución, o necesitar almacenar cierres entre funciones. |
Casos de uso comunes
Los cierres son comunes en el desarrollo diario de Rust; a continuación se muestran algunos de los escenarios de aplicación más típicos.
Clausuras en iteradores
Los cierres se usan a menudo junto con métodos de iterador para procesar por lotes los elementos de una colección.
Ejemplo
let nums = vec![1, 2, 3, 4, 5];
// map: transforma cada elemento
let squared: Vec<i32> = nums.iter().map(|x| x * x).collect();
println!("cuadrado: {:?}", squared); // Salida: [1, 4, 9, 16, 25]
// filter: filtra los elementos que cumplen la condición
let even: Vec<&i32> = nums.iter().filter(|x| *x % 2 == 0).collect();
println!("pares: {:?}", even); // Salida: [2, 4]
// fold: reduce la colección a un solo valor
let sum: i32 = nums.iter().fold(0, |acc, x| acc + x);
println!("suma: {}", sum); // Salida: 15
}
Clausuras y multihilo
En programación multihilo, los cierres se usan a menudo para definir el cuerpo de ejecución de un hilo.moveLa palabra clave `move` es casi obligatoria en este escenario, porque mueve la propiedad de los datos al nuevo hilo y evita referencias inválidas entre hilos.
Ejemplo
fn main() {
let nums = vec![1, 2, 3, 4, 5];
// Crea un hilo para cada número; `move` mueve la propiedad de `num` al hilo
let handles: Vec<_> = nums.into_iter().map(|num| {
thread::spawn(move || {
num * 2
})
}).collect();
// Espera a que todos los hilos terminen y recopila los resultados
for handle in handles {
let result = handle.join().unwrap();
println!("Result: {}", result);
}
}
Clausuras y manejo de errores
Los cierres pueden devolverResultoOptiontipos, y junto con los métodos de iterador implementan una lógica de manejo de errores concisa.
Ejemplo
let nums = vec![3, -1, 4, -5, 9];
// Usa un cierre para encontrar el primer número positivo
let first_positive = nums.iter().find(|&&x| x > 0);
match first_positive {
Some(&n) => println!("primer número positivo: {}", n), // Salida: primer número positivo: 3
None => println!("sin números positivos"),
}
// Usa cierres para filtrar y transformar, junto con `Result` para manejar posibles errores
let results: Vec<Result<i32, &str>> = nums.iter().map(|&n| {
if n > 0 {
Ok(n * 10)
} else {
Err("no se pueden procesar números negativos")
}
}).collect();
for r in results {
match r {
Ok(v) => println!("éxito: {}", v),
Err(e) => println!("error: {}", e),
}
}
}
Rendimiento y ciclo de vida
Rendimiento de las clausuras
Los cierres de Rust son livianos. El compilador realiza optimizaciones en línea sobre los cierres, lo que hace que el costo de una llamada a un cierre sea cercano al de llamar directamente a una función normal. Los cierres en sí no introducen llamadas a funciones virtuales ni asignaciones en el montón adicionales (a menos que se use explícitamenteBox)。
Clausuras y ciclo de vida
El ciclo de vida de un cierre está estrechamente relacionado con las variables que captura. El sistema de ciclos de vida de Rust garantiza que un cierre no viva más que cualquiera de las variables que captura: si un cierre hace referencia a una variable local, el compilador evitará en tiempo de compilación que devuelvas el cierre fuera del ámbito de esa variable.
Ejemplo
let text = String::from("ejemplo");
// Correcto: el cierre se usa dentro del ámbito de `text`
let print_text = || println!("{}", text);
print_text(); // Salida: ejemplo
// Si intentas devolver este cierre, el compilador mostrará un error:
// fn make_closure() -> impl Fn() {
// let text = String::from("ejemplo");
// || println!("{}", text) // Error: el ciclo de vida de `text` no es suficientemente largo
// }
// Solución: usa `move` para mover la propiedad al cierre
}
Ejemplo completo
El siguiente ejemplo demuestra de manera integral los usos principales de los cierres: declaración, captura de variables externas, paso como parámetro, etc.
Ejemplo
fn apply_operation<F>(num: i32, operation: F) -> i32
where
F: Fn(i32) -> i32,
{
operation(num)
}
fn main() {
let num = 5;
// Define un cierre: calcula el cuadrado de un número
let square = |x| x * x;
// Pasa el cierre como argumento a la función
let result = apply_operation(num, square);
println!("Square of {} is {}", num, result); // Salida: Square of 5 is 25
// También puedes pasar directamente un cierre anónimo
let result2 = apply_operation(num, |x| x * x * x);
println!("Cube of {} is {}", num, result2); // Salida: Cube of 5 is 125
}
Al ejecutar el programa, la salida es la siguiente:
Square of 5 is 25 Cube of 5 is 125
Resumen
Los cierres de Rust son una abstracción poderosa que proporciona una manera flexible y expresiva de encapsular lógica.
Los cierres pueden capturar variables del entorno y pueden pasarse como argumentos o devolverse como valor de retorno. Combinados con iteradores, permiten implementar fácilmente tareas complejas de procesamiento de datos.
El diseño de los cierres de Rust equilibra seguridad, rendimiento y ciclo de vida: el compilador garantiza en tiempo de compilación que los cierres no hagan referencia a variables que ya no son válidas, y mediante optimizaciones en línea asegura una abstracción de costo cero en las llamadas a cierres.
Otras extensiones