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ísticaClausuraFunción
AnonimatoNo tiene nombre y normalmente se asigna a una variableTiene unfnnombre fijo
Captura de entornoPuede capturar variables externasNo puede capturar variables externas
Forma de definición|parámetros| expresiónfn nombre(parámetros)
Inferencia de tiposLos tipos de los parámetros y del valor de retorno generalmente se pueden omitirDeben especificarse explícitamente los tipos de los parámetros y del valor de retorno
Almacenamiento y transmisiónPuede usarse como variable, parámetro o valor de retornoTambié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

fn main() {
    // 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 capturaSemántica de Rust correspondienteDescripción
Captura por referenciaSimilar a&TComportamiento predeterminado: la clausura toma prestada la variable, el exterior aún puede usarla
Captura con préstamo mutableSimilar a&mut TLa clausura necesita modificar la variable; la propia clausura debe declararse como `mut`mut
Captura por valorSimilar aTUsamovela palabra clave `move`, que transfiere la propiedad de la variable a la clausura

Para tipos que implementan elCopytrait `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

fn main() {
    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

fn main() {
    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

fn main() {
    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.

TraitMétodo de capturaNúmero de invocaciones posiblesEscenario típico
FnPréstamo inmutable (`Fn`)&T)Múltiples vecesAcceso de solo lectura a las variables capturadas
FnMutPréstamo mutable (`FnMut`)&mut T)Múltiples vecesNecesita modificar las variables capturadas
FnOnceToma de posesión (`FnOnce`)T)Solo una vezConsume 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

fn main() {
    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

// Definir una función que acepta una clausura como parámetro
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

// Devuelve una clausura que captura el parámetro `x` y lo suma al valor pasado
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

fn make_adder(x: i32) -> Box<dyn Fn(i32) -> i32> {
    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étodoUbicación de asignaciónEscenario aplicable
impl FnpilaEl tipo de cierre se puede determinar en tiempo de compilación, con mejor rendimiento.
Box<dyn Fn>montículoElegir 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

fn main() {
    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

use std::thread;

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

fn main() {
    let nums = vec![3, -1, 4, -5, 9];

    // Usa un cierre para encontrar el primer número positivo
    let first_positive = nums.iter().find(|&amp;&amp;x| x > 0);
    match first_positive {
        Some(&amp;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, &amp;str>> = nums.iter().map(|&amp;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

fn main() {
    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

// Define una función que acepta un cierre como parámetro
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