Desempaquetar un 'Option'

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

A veces necesitas extraer el valor real de un Option cuando estás seguro de que contiene un Some. Rust proporciona el método .unwrap() para este propósito: extrae el valor de un Some y te lo entrega directamente.

let maybe_number = Some(42);
let actual_number = maybe_number.unwrap();
println!("The number is: {}", actual_number);

Cuando llamas a .unwrap() en un Some(value), devuelve el valor interno. En el ejemplo anterior, actual_number se convierte en 42; ya no está envuelto en un Option.

Sin embargo, hay una advertencia crítica: si llamas a .unwrap() en un None, tu programa entrará en pánico y fallará inmediatamente. Esto hace que .unwrap() sea un método potencialmente peligroso que solo debe usarse cuando estés absolutamente seguro de que el Option contiene un Some.

let empty_option: Option<i32> = None;
let value = empty_option.unwrap(); // ¡Esto causará un pánico!

Utiliza .unwrap() con moderación y solo en situaciones donde puedas garantizar que el Option contiene un valor, como en ejemplos sencillos o cuando ya hayas comprobado con .is_some().

Desafío

Fácil

Recibirás dos entradas. La primera entrada es un número (como una cadena), y la segunda entrada indica si este número debe tratarse como válido o inválido. Si la segunda entrada es valid, crea un Option<i32> que contenga Some con el número analizado. Si la segunda entrada es invalid, crea un Option<i32> que contenga None. Usa .unwrap() para extraer el valor del Option e imprímelo.

Requerimientos:

Lee la primera entrada y elimina los espacios en blanco
Lee la segunda entrada y elimina los espacios en blanco
Analiza la primera entrada a i32 usando .parse::<i32>()
Crea una variable Option<i32>:
- Si la segunda entrada es valid, asigna Some(parsed_number)
- Si la segunda entrada es invalid, asigna None
Usa .unwrap() para extraer el valor del Option
Imprime el valor extraído en el formato: Value: [number]

Entrada:

Primera línea: Un número como una cadena (por ejemplo, 42)
Segunda línea: Ya sea valid o invalid

Salida:

Si la segunda entrada es valid: Value: [number]
Si la segunda entrada es invalid: El programa entrará en pánico (este es el comportamiento esperado para este desafío)

Nota: Cuando la segunda entrada es invalid, llamar a .unwrap() sobre None causará un pánico. Esto demuestra la naturaleza peligrosa de .unwrap() cuando no estás seguro de que el Option contiene un valor.

Hoja de referencia

El método .unwrap() extrae el valor de un Option<T>:

let maybe_number = Some(42);
let actual_number = maybe_number.unwrap();
println!("The number is: {}", actual_number); // Imprime: The number is: 42

Advertencia: Llamar a .unwrap() en un None causará que tu programa entre en pánico (panic) y se bloquee:

let empty_option: Option<i32> = None;
let value = empty_option.unwrap(); // ¡Esto entrará en pánico!

Usa .unwrap() solo cuando estés absolutamente seguro de que el Option contiene un valor Some.

Pruébalo tú mismo

use std::io;

fn main() {
    // Leer la primera entrada (número como cadena)
    let mut number_input = String::new();
    io::stdin().read_line(&mut number_input).expect("Failed to read line");
    let number_input = number_input.trim();
    
    // Leer la segunda entrada (válida o inválida)
    let mut validity_input = String::new();
    io::stdin().read_line(&mut validity_input).expect("Failed to read line");
    let validity_input = validity_input.trim();
    
    // Analizar el número
    let parsed_number: i32 = number_input.parse().expect("Failed to parse number");
    
    // TODO: Escribe tu código a continuación
    // Crear un Option<i32> basado en validity_input
    // Si validity_input es "valid", asignar Some(parsed_number)
    // Si validity_input es "invalid", asignar None
    // Luego usar .unwrap() para extraer el valor e imprimirlo en el formato: Value: [number]
    
}