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 fornisce un operatore elegante per questo schema comune: l'operatore punto interrogativo ?.

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

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

È equivalente a scrivere un'istruzione match completa, ma è 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 convertire la stringa durante il parsing. 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 il parsing non riesce.

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

Sfida

Facile

Riceverai due input. Il primo input è una stringa che deve essere convertita in un intero e il secondo input è un'altra stringa che deve anch'essa essere convertita in un intero. Crea una funzione chiamata add_numbers che accetta due sezioni di stringa come parametri e restituisce un Result<i32, std::num::ParseIntError>. All'interno della funzione, usa l'operatore ? per convertire 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, converti la prima stringa in i32 usando l'operatore ?
Converti la seconda stringa in i32 usando l'operatore ?
Restituisci Ok(sum), dove sum è la somma dei due numeri convertiti
Chiama la funzione con le due stringhe di input
Usa un'espressione match per gestire il Result
Nel braccio Ok(value), stampa: Sum: [value]
Nel braccio 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 una delle due stringhe non può essere convertita: 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(_)
}