Le type `Result<T, E>` pour les opérations pouvant échouer (`Ok`, `Err`)

Modéliser le succès et l'échec : la puissance de `Result<T, E>`

Dans de nombreuses situations de programmation, une opération peut ne pas toujours réussir. Pensez à la lecture d'un fichier (le fichier peut ne pas exister ou vous pourriez ne pas avoir les permissions), à une requête réseau (le serveur peut être indisponible), ou à l'analyse d'une entrée utilisateur (l'entrée peut être malformée). Rust fournit un mécanisme élégant et robuste pour gérer ces scénarios : le type énuméré `Result<T, E>`.

Comme `Option<T>` qui gère l'absence de valeur, `Result<T, E>` utilise le système de types pour rendre la gestion des erreurs explicite et sûre. `T` est un paramètre de type générique représentant le type de la valeur retournée en cas de succès, et `E` est un autre paramètre de type générique représentant le type de l'erreur retournée en cas d'échec. Cette généricité permet d'utiliser `Result` dans une multitude de contextes avec des types de succès et d'erreur spécifiques.

L'utilisation de `Result<T, E>` force le programmeur à reconnaître qu'une opération peut échouer et à gérer explicitement ce cas. Cela contraste avec les exceptions non vérifiées d'autres langages, où une erreur peut se propager silencieusement jusqu'à provoquer un plantage inattendu si elle n'est pas attrapée quelque part.

Les deux issues d'une opération : `Ok(T)` et `Err(E)`

Le type `Result<T, E>` est une énumération avec deux variantes possibles :

• Ok(T) : Cette variante indique que l'opération a réussi. Elle encapsule la valeur de succès, de type `T`. Par exemple, si une fonction analyse une chaîne de caractères pour en extraire un nombre, en cas de succès, elle pourrait retourner Ok(nombre_extrait).
• Err(E) : Cette variante indique que l'opération a échoué. Elle encapsule une valeur d'erreur, de type `E`, qui peut fournir des informations sur la nature de l'échec. Par exemple, si la lecture d'un fichier échoue, la fonction pourrait retourner Err(erreur_io_specifique).

Voici la définition simplifiée de `Result<T, E>` (la définition réelle se trouve dans la bibliothèque standard et fait partie du prélude) :

enum Result<T, E> {
    Ok(T),   // Variante pour le succès, contenant une valeur de type T
    Err(E),  // Variante pour l'erreur, contenant une valeur de type E
}

Cette structure permet non seulement de savoir si une opération a réussi ou échoué, mais aussi d'obtenir la valeur de succès ou des détails sur l'erreur, le tout de manière typée et vérifiée par le compilateur.

Gestion des `Result` avec `match` et exemples concrets

Similairement à `Option<T>`, l'expression `match` est l'outil fondamental pour travailler avec des valeurs de type `Result<T, E>`. Elle permet de prendre des chemins différents en fonction du succès (`Ok`) ou de l'échec (`Err`) et d'accéder aux valeurs encapsulées.

Considérons une fonction qui tente de convertir une chaîne de caractères en un entier. La bibliothèque standard de Rust fournit `str::parse()`, qui retourne un `Result`.

fn convertir_en_i32(s: &str) -> Result {
    // s.parse() retourne Result
    // ParseIntError est le type d'erreur spécifique pour l'échec de l'analyse d'un entier.
    s.parse()
}

fn main() {
    let chaine_valide = "123";
    let chaine_invalide = "abc";

    println!("Analyse de '{}':", chaine_valide);
    match convertir_en_i32(chaine_valide) {
        Ok(nombre) => println!("  Succès ! Nombre : {}", nombre),
        Err(e) => println!("  Echec ! Erreur : {}", e),
    }
    // Sortie pour chaine_valide :
    // Analyse de '123':
    //   Succès ! Nombre : 123

    println!("\nAnalyse de '{}':", chaine_invalide);
    match convertir_en_i32(chaine_invalide) {
        Ok(nombre) => println!("  Succès ! Nombre : {}", nombre),
        Err(e) => println!("  Echec ! Erreur : {}", e), // e sera de type ParseIntError
    }
    // Sortie pour chaine_invalide :
    // Analyse de 'abc':
    //   Echec ! Erreur : invalid digit found in string
}

Ici, `match` nous assure que nous traitons les deux cas. Si `convertir_en_i32` retourne `Ok(nombre)`, nous pouvons utiliser `nombre`. Si elle retourne `Err(e)`, nous avons accès à l'erreur `e` pour, par exemple, l'afficher ou la journaliser. Le type de `e` est `std::num::ParseIntError`, ce qui nous permet de savoir exactement quel genre d'information d'erreur nous manipulons.

La fonction `File::open` de la bibliothèque standard est un autre excellent exemple d'utilisation de `Result` :

use std::fs::File;
use std::io;

fn main() {
    let nom_fichier = "mon_fichier.txt";

    match File::open(nom_fichier) { // File::open retourne Result
        Ok(fichier) => {
            println!("Le fichier '{}' a été ouvert avec succès.", nom_fichier);
            // On peut maintenant travailler avec `fichier`
        }
        Err(erreur) => {
            // `erreur` est de type io::Error, qui peut avoir différentes causes
            match erreur.kind() { // io::Error a une méthode kind() pour plus de détails
                io::ErrorKind::NotFound => {
                    println!("Le fichier '{}' n'a pas été trouvé.", nom_fichier);
                }
                io::ErrorKind::PermissionDenied => {
                    println!("Permission refusée pour ouvrir '{}'.", nom_fichier);
                }
                _ => { // Gérer d'autres types d'erreurs io
                    println!("Une erreur d'entrée/sortie est survenue avec '{}': {}", nom_fichier, erreur);
                }
            }
        }
    }
}

Cet exemple montre aussi comment on peut imbriquer des `match` ou utiliser des méthodes sur le type d'erreur (`io::Error::kind()`) pour obtenir des informations plus précises sur l'échec et y réagir de manière appropriée.

Propagation d'erreurs et l'opérateur `?`

Bien que `match` soit fondamental, écrire des `match` imbriqués pour chaque opération faillible peut rendre le code verbeux. Rust offre un sucre syntaxique très pratique pour propager les erreurs : l'opérateur `?`.

L'opérateur `?` ne peut être utilisé que dans des fonctions qui retournent elles-mêmes un `Result` (ou un `Option`). Lorsqu'il est appliqué à une valeur `Result<T, E>` :

• Si la valeur est `Ok(valeur)`, l'opérateur `?` extrait `valeur` et l'expression continue.
• Si la valeur est `Err(erreur)`, l'opérateur `?` provoque un retour immédiat de la fonction englobante, en propageant cette `erreur`. (Note : le type d'erreur de l'expression avec `?` doit être convertible vers le type d'erreur de la fonction englobante via le trait `From`.)

Voici un exemple :

use std::fs::File;
use std::io::{self, Read};

fn lire_fichier_en_chaine(nom_fichier: &str) -> Result {
    let mut f = File::open(nom_fichier)?; // Si File::open() retourne Err, la fonction retourne cette erreur.
                                       // Sinon, `f` contient le File.
    let mut s = String::new();
    f.read_to_string(&mut s)?; // Si read_to_string() retourne Err, la fonction retourne cette erreur.
                              // Sinon, `s` contient le contenu du fichier.
    Ok(s) // Si tout s'est bien passé, retourne Ok(contenu_du_fichier).
}

fn main() {
    match lire_fichier_en_chaine("message.txt") { // Supposons que message.txt existe
        Ok(contenu) => println!("Contenu du fichier :\n{}", contenu),
        Err(e) => println!("Erreur lors de la lecture du fichier : {}", e),
    }
}

L'opérateur `?` simplifie grandement le code de gestion d'erreur en se concentrant sur le "chemin heureux" (happy path) tout en s'assurant que les erreurs sont correctement propagées vers l'appelant. C'est une des fonctionnalités les plus appréciées pour écrire du code Rust concis et robuste.

En conclusion, `Result<T, E>` avec ses variantes `Ok(T)` et `Err(E)` est le mécanisme privilégié en Rust pour la gestion des erreurs récupérables. Il favorise un code où les échecs possibles sont explicitement indiqués par le système de types et où leur gestion est imposée par le compilateur, conduisant à des applications plus fiables.