Closures con parámetros

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

Si bien los closures que no reciben parámetros son útiles, la mayoría de las veces querrás pasar datos a tus closures para hacerlos más flexibles y potentes. Agregar parámetros a los closures sigue el mismo patrón que aprendiste anteriormente, pero con valores dentro de las barras verticales.

Aquí tienes cómo definir un closure que acepta un parámetro:

let add_one = |x: i32| x + 1;

Observa que el parámetro x va entre las barras verticales, al igual que los parámetros de una función. Luego puedes llamar a este closure pasando un valor:

let add_one = |x: i32| x + 1;
let result = add_one(5); // el resultado es 6

Para los closures con múltiples parámetros, sepáralos con comas:

let multiply = |x: i32, y: i32| x * y;
let result = multiply(3, 4); // el resultado es 12

Desafío

Fácil

Recibirás dos entradas. La primera entrada es un número y la segunda entrada también es un número. Crea un closure que tome dos parámetros y calcule la potencia (el primer parámetro elevado al segundo parámetro). Almacena el closure en una variable, llámalo con los valores de entrada e imprime el resultado.

Requisitos:

Lee la primera entrada (número base) y elimina los espacios en blanco
Parsea la entrada a i32
Lee la segunda entrada (exponente) y elimina los espacios en blanco
Parsea la entrada a u32
Crea un closure con dos parámetros que calcule la potencia utilizando el método .pow()
Almacena el closure en una variable
Llama al closure con ambos valores de entrada
Imprime el resultado

Entrada:

Primera línea: Un número base (por ejemplo, 2)
Segunda línea: Un exponente (por ejemplo, 3)

Salida:

El resultado del cálculo de la potencia

Hoja de referencia

Los closures pueden aceptar parámetros colocándolos entre las barras verticales ||:

let add_one = |x: i32| x + 1;
let result = add_one(5); // el resultado es 6

Para múltiples parámetros, sepárelos con comas:

let multiply = |x: i32, y: i32| x * y;
let result = multiply(3, 4); // el resultado es 12

Pruébalo tú mismo

use std::io;

fn main() {
    // Leer la primera entrada (número base)
    let mut base_input = String::new();
    io::stdin().read_line(&mut base_input).expect("Failed to read line");
    let base: i32 = base_input.trim().parse().expect("Invalid number");
    
    // Leer la segunda entrada (exponente)
    let mut exp_input = String::new();
    io::stdin().read_line(&mut exp_input).expect("Failed to read line");
    let exponent: u32 = exp_input.trim().parse().expect("Invalid number");
    
    // TODO: Crear un cierre (closure) que calcule la potencia y almacenarlo en una variable
    // TODO: Llamar al cierre con la base y el exponente
    
    // Imprimir el resultado
    println!("{}", result);
}