L’operatore punto interrogativo «?»

Fa parte della sezione Logica e flusso del percorso Rust di Coddy. Lezione 46 di 66.

Quando lavori con funzioni che restituiscono Result, spesso devi gestire gli errori occupandotene localmente oppure propagandoli alla funzione chiamante. Rust offre un operatore elegante per questo schema comune: l’operatore punto interrogativo ?.

L'operatore ? offre un modo chiaro per propagare gli errori senza scrivere istruzioni match prolisse. Quando aggiungi ? dopo un Result, estrae automaticamente il valore Ok oppure restituisce immediatamente dalla funzione corrente con l'Err:

fn parse_and_double(s: &str) -> Result<i32, std::num::ParseIntError> {
    let number = s.parse::<i32>()?; // Se l'analisi fallisce, restituisci l'errore
    Ok(number * 2) // Se riesce, raddoppia il numero
}

Questo equivale a scrivere un'intera istruzione match, ma in modo molto più conciso. Se s.parse::<i32>() restituisce un Ok, ? estrae il valore e lo assegna a number. Se restituisce un Err, ? restituisce immediatamente quell'errore dall'intera funzione.

Nota la sintassi ::<i32>. Si chiama turbofish e indica a Rust in quale tipo analizzare la stringa. La funzione restituisce Result<i32, std::num::ParseIntError>, dove i32 è il tipo restituito in caso di successo e std::num::ParseIntError è il tipo di errore restituito quando l’analisi non riesce.

L’operatore ? può essere usato solo nelle funzioni che restituiscono un Result (o Option), perché deve poter restituire un errore.

Sfida

Facile

Riceverai due input. Il primo input è una stringa che deve essere analizzata come intero, mentre il secondo input è un'altra stringa che deve essere anch'essa analizzata come intero. Crea una funzione chiamata add_numbers che accetta due slice di stringa come parametri e restituisce un Result<i32, std::num::ParseIntError>. All'interno della funzione, usa l'operatore ? per analizzare entrambe le stringhe e restituire la loro somma racchiusa in Ok. Chiama la funzione con i due input e gestisci il risultato usando match.

Requisiti:

Leggi il primo input (il primo numero come stringa) e rimuovi gli spazi bianchi
Leggi il secondo input (il secondo numero come stringa) e rimuovi gli spazi bianchi
Crea una funzione add_numbers che accetta due parametri &str e restituisce Result<i32, std::num::ParseIntError>
All'interno della funzione, analizza la prima stringa come i32 usando l'operatore ?
Analizza la seconda stringa come i32 usando l'operatore ?
Restituisci Ok(sum) dove sum è la somma dei due numeri analizzati
Chiama la funzione con le due stringhe di input
Usa un'espressione match per gestire il Result
Nel ramo Ok(value), stampa: Sum: [value]
Nel ramo Err(_), stampa: Parsing error

Input:

Prima riga: una stringa che rappresenta un numero (ad es., 15)
Seconda riga: una stringa che rappresenta un altro numero (ad es., 27)

Output:

Se entrambe le stringhe sono numeri validi: Sum: [result]
Se non è possibile analizzare una delle due stringhe: Parsing error

Provalo tu

use std::io;

// TODO: Crea qui la funzione add_numbers
// Deve accettare due parametri &str e restituire Result<i32, std::num::ParseIntError>


fn main() {
    // Leggi il primo input
    let mut input1 = String::new();
    io::stdin().read_line(&mut input1).expect("Failed to read line");
    let input1 = input1.trim();
    
    // Leggi il secondo input
    let mut input2 = String::new();
    io::stdin().read_line(&mut input2).expect("Failed to read line");
    let input2 = input2.trim();
    
    // TODO: Chiama add_numbers con input1 e input2
    // TODO: Usa match per gestire il Result
    // Stampa "Sum: [value]" per Ok(value)
    // Stampa "Parsing error" per Err(_)
}