Capturar el entorno

Parte de la sección Logic & Flow del Journey de Rust de Coddy — lección 62 de 66.

Una de las características más potentes de los closures es su capacidad para capturar y utilizar variables de su entorno circundante. A diferencia de las funciones regulares, los closures pueden «ver» y acceder a variables que existen en el mismo ámbito donde se definen.

Así es como funciona la captura del entorno:

fn main() {
    let x = 10;
    
    let my_closure = || {
        println!("The value of x is: {}", x);
    };
    
    my_closure(); // Esto imprimirá "The value of x is: 10"
}

En este ejemplo, el closure captura la variable x del ámbito circundante y la utiliza dentro de su cuerpo. El closure no necesita que x sea pasada como parámetro; automáticamente tiene acceso a ella.

También puedes capturar variables y usarlas en cálculos:

let multiplier = 3;
let multiply_by_three = |num| num * multiplier;
let result = multiply_by_three(5); // el resultado es 15

Desafío

Fácil

Recibirás dos entradas. La primera entrada es un número que representa un precio base. La segunda entrada es un número que representa un porcentaje de descuento. Crea un closure que capture el porcentaje de descuento del entorno y calcule el precio final después de aplicar el descuento. Llama al closure con el precio base e imprime el precio final.

Requisitos:

Lee la primera entrada (precio base) y elimina los espacios en blanco
Parsea el valor a f64
Lee la segunda entrada (porcentaje de descuento) y elimina los espacios en blanco
Parsea el valor a f64
Crea un closure que tome un parámetro (el precio base) y capture el porcentaje de descuento del entorno circundante
El closure debe calcular el precio final usando la fórmula: base_price - (base_price * discount / 100.0)
Llama al closure con el precio base
Imprime el precio final

Entrada:

Primera línea: Un precio base (por ejemplo, 100.0)
Segunda línea: Un porcentaje de descuento (por ejemplo, 20.0)

Salida:

El precio final después de aplicar el descuento

Hoja de referencia

Los cierres (closures) pueden capturar y utilizar variables de su entorno circundante sin necesidad de pasarlas como parámetros.

Captura básica del entorno:

let x = 10;

let my_closure = || {
    println!("The value of x is: {}", x);
};

my_closure(); // Imprime "The value of x is: 10"

Captura de variables en cálculos:

let multiplier = 3;
let multiply_by_three = |num| num * multiplier;
let result = multiply_by_three(5); // el resultado es 15

El cierre captura automáticamente multiplier del entorno circundante y lo utiliza en el cálculo.

Pruébalo tú mismo

use std::io;

fn main() {
    // Leer el precio base
    let mut base_price_input = String::new();
    io::stdin().read_line(&mut base_price_input).expect("Failed to read line");
    let base_price: f64 = base_price_input.trim().parse().expect("Invalid number");
    
    // Leer el porcentaje de descuento
    let mut discount_input = String::new();
    io::stdin().read_line(&mut discount_input).expect("Failed to read line");
    let discount: f64 = discount_input.trim().parse().expect("Invalid number");
    
    // TODO: Crear un closure que capture el descuento y calcule el precio final
    // TODO: Llamar al closure con el precio base
    
    // Imprimir el precio final
    // println!("{}", final_price);
}