Réponse.

Historique de la question

De nombreux langages de programmation permettent l'utilisation de valeurs nulles, ce qui entraîne des erreurs de dereferencement de pointeur nul à l'exécution. En Rust, pour représenter explicitement des valeurs optionnelles, un type générique Option<T> a été introduit, qui garantit la sécurité et, ce qui est important, oblige à prendre en compte le cas de l'absence de valeur.

Problème

L'absence de valeur (par exemple, si le résultat d'une recherche n'est pas trouvé) entraîne souvent des erreurs à l'exécution si cela n'est pas reflété dans le type. Une gestion sécurisée et explicite du cas d'une valeur nulle réduit le nombre de bogues.

Solution

Le type Option<T> est implémenté sous forme d'enum avec deux variantes : Some(T) (valeur présente) et None (valeur absente). Cela permet au compilateur d'obliger le programmeur à considérer les deux cas. Toute utilisation d'une valeur optionnelle sans vérification explicite entraîne une erreur de compilation.

Exemple de code :

fn divide(a: i32, b: i32) -> Option<i32> {
    if b == 0 { None } else { Some(a / b) }
}

let res = divide(6, 3);
match res {
    Some(result) => println!("Résultat : {}", result),
    None => println!("Division par zéro !"),
}

Caractéristiques clés :

Pas de pointeurs nuls : l'absence de valeur fait partie du type, et non d'une valeur magique.
Le développeur est obligé de traiter les deux cas — présence et absence de valeur.
Compatible avec le pattern matching, ce qui facilite le traitement flexible de la logique.

Questions pièges.

Est-ce que Option<T> est une abstraction zero-cost, ou chaque variable Option prend-elle plus d'espace ?

Oui, dans la plupart des cas, Option<T> est zero-cost lorsque le type T ne peut pas prendre de "valeur nulle" (par exemple, un type référentiel ou Box<T>). Rust utilise l'optimisation "nullable pointer optimization", et aucune mémoire supplémentaire n'est requise.

let value: Option<&u32> = None;
// Ne prend pas plus de place qu'une référence ordinaire.

Peut-on utiliser unwrap sans crainte ?

Non, unwrap() provoque une panique en cas de valeur None. Il convient de l'utiliser uniquement lorsque l'on est certain que la valeur est présente, ou de préférer les méthodes unwrap_or, unwrap_or_else, ou le pattern matching.

Quelle est la différence entre Option et les références (&T, Option<&T>) ?

Une référence pointe toujours vers une valeur existante. Si la valeur est absente, il faut utiliser Option<&T> pour refléter explicitement "peut-être rien". Utiliser Option au lieu d'une référence directe prévient les conditions de concurrence liées aux pointeurs nuls.

Erreurs typiques et anti-patterns

Utilisation de unwrap partout sans vérification, ce qui entraîne des paniques.
Mélange d'Option<&T> et de références, lorsque le choix n'est pas justifié par la logique.
Conversion d'Option en Result ou un autre type sans choix conscient.

Exemple de la vie réelle

Cas négatif

La fonction retourne un résultat de recherche via Option, mais le code appelant utilise unwrap, persuadé qu'il y a toujours un résultat. En réalité, en cas d'absence de valeur, le programme plante en production.

Avantages :

Code concis lors de la phase de prototypage.

Inconvénients :

Les situations non détectées peuvent être faciles à manquer, ce qui peut entraîner une conclusion disgracieuse de l'application.

Cas positif

Le code utilise match pour traiter l'Option, tous les cas sont clairement documentés et couverts par des tests.