Rust: un vistazo más (4), uso de clousures

Un closure (o clausura) es un concepto en lenguajes como JavaScript o Python, y que lenguajes Rust permite implementar.

Es la manera en como una función dentro de otra función contenedora puede hacer referencia a las variables después de que la función contenedora ha terminado de ejecutarse.

Crearemos un clousure para sumar dos números enteros (de tipo i32):

let suma_numeros = |x:i32, y:i32| x + y;

Ahora invocaremos la función:

 fn main(){
   // Clousure para sumar dos números enteros (i32)
   let suma_numeros = |x:i32, y:i32| x + y;
   let m = 34;
   let n = 21 as i32;
   // Invocamos el clousure
   println!("Suma con clousure de {} + {} es {} ", m,n, suma_numeros(m,n));
}

Salida:

Suma con clousure de 34 + 21 es 55

El uso de clousures nos permitirá usar variables externas, lo que no se puede hacer con funciones "clásicas" o estandard. Veamos un ejemplo:

fn test_c(){
    let suma_numeros = |x:i32, y:i32| x + y;
    let m = 34;
    let n = 21 as i32;
    println!("Suma con clousure de {} + {} es {} ", m,n, suma_numeros(m,n));
    
    // Podemos usar variables externas, lo que no se puede hacer con funciones estandard
    let z = 32 as i32;
    let suma_numeros = |x:i32, y:i32| x + y + z;
    println!("Suma con clousure de {} + {} + {} es {} ", m,n,z, suma_numeros(m,n));
    
}

Salida:

Suma con clousure de 34 + 21 es 55
Suma con clousure de 34 + 21 + 32 es 87

Los clousures también pueden denominarse como funciones anónimas y su uso es más habitual en casi cualquier lenguaje de programación actualmente.

El uso de estas funciones es muy útil. Crearemos un closure que calcule el número factorial de un número entero.

factorial.rs

fn main(){

  // Definimos una variable que el closure va a capturar
    let calcular_factorial = |n: u32| -> u32 {
        let mut resultado = 1;
        for i in 1..=n {
            resultado *= i;
        }
        resultado
    };

    // Probamos el closure con algunos valores
    let numero = 5;
    println!("El factorial de {} es {}", numero, calcular_factorial(numero));
    println!("El factorial de 3 es {}", calcular_factorial(3));
    println!("El factorial de 0 es {}", calcular_factorial(0));

}

Compilamos y ejecutamos:

$ rustc factorial.rs
$ ./factorial.exe

Salida:

El factorial de 5 es 120
El factorial de 3 es 6
El factorial de 0 es 1

Continuaremos con Rust en próximas entregas.

Enlaces:

https://lineadecodigo.com/groovy/groovy-un-vistazo-a-los-closures-2/