Gestire gli errori in Rust

La gestione degli errori in Rust è un pò più complicata rispetto ad altri linguaggi ai quali siamo abituati.

E questo, prima di tutto, perchè non c'è una classica gestione delle eccezioni.

Comunque, in generale, in rust abbiamo due tipi di errori:

• Recoverable ->errori che possono essere intercettati, e quindi possono essere in qualche maniera corretti. o che comunque non causano il crash dell'applicazione
• UnReceverable -> errori che non possono essere intrcettati

Per quanto riguarda gli strumenti che possiamo usare, comincerei dalla macro panic:

fn main() {
    let no = 13;
    if no % 2 == 0 {
        println!("OK");
    } else {
        panic!("KO");
    }
    println!("FINE");
}

Questa macro termina subito l'applicazione senza arrivare alla fine, resituendo un messaggio che può essere utile all'utente.

Diciamo che è facile e veloce da usare, ma non sempre può andare bene.

Un modo più elegante è usare l'Enum Result.

Prendiamo come esempio l'apertura di un file che non esiste:

use std::fs::File;
use std::error::Error;

fn main() {
    let f = File::open("test.txt");
    match f {
        Ok(f) => {
            println!("FILE TROVATO {:?}", f);
        }
        Err(e) => {
            println!("FILE NON TROVATO: {:?} - {:?} - {:?}", e.description(), e.kind(), e.to_string());
        }
    }
    println!("FINE");
}

Questo sarà il risultato:

FILE NON TROVATO: "entity not found" - NotFound - "No such file or directory (os error 2)"
FINE

Quindi si arriva alla fine del programma; questo esempio ricorda un pò l'uso del try/catch.

Un helper interessante è expect, che ritorna solo un messaggio di errore nel caso in cui vada in panico:

use std::fs::File;

fn main() {
    let f = File::open("test.txt").expect("File non trovato");
    println!("FINE");
}

In questo caso il programma si bloccherà rimandando un errore; rispetto alla macro panic, expect fa un controllo in automatico.

Enjoy!