{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Quel type Rust représente une valeur qui peut être présente ou absente ?","acceptedAnswer":{"@type":"Answer","text":"Option est un enum qui peut être soit Some(T) contenant une valeur, soit None indiquant l'absence de valeur. Ce type remplace les valeurs null présentes dans d'autres langages et force le développeur à gérer explicitement le cas où la valeur est absente, évitant ainsi les erreurs de pointeur null à l'exécution."}},{"@type":"Question","name":"Quel type Rust représente une opération qui peut réussir ou échouer avec une erreur ?","acceptedAnswer":{"@type":"Answer","text":"Result est un enum avec deux variantes : Ok(T) pour le succès contenant la valeur de retour, et Err(E) pour l'échec contenant l'erreur. Ce type oblige à gérer les erreurs explicitement plutôt que d'utiliser des exceptions, rendant le code plus prévisible et les erreurs plus visibles."}},{"@type":"Question","name":"Que fait la méthode unwrap() sur un Option ?","acceptedAnswer":{"@type":"Answer","text":"unwrap() retourne la valeur contenue dans Some(T) si elle existe. Si l'Option est None, le programme panique (panic!) et s'arrête immédiatement. Cette méthode est pratique pour le prototypage mais doit être évitée en production car elle ne gère pas gracieusement le cas None."}},{"@type":"Question","name":"Quelle est la différence entre unwrap() et expect() ?","acceptedAnswer":{"@type":"Answer","text":"expect() fonctionne comme unwrap() mais permet de spécifier un message d'erreur personnalisé qui sera affiché en cas de panique. Cela facilite le débogage en indiquant clairement pourquoi le programme a paniqué. expect() est préféré à unwrap() car il donne plus de contexte lors des erreurs."}},{"@type":"Question","name":"Que fait l'opérateur ? dans une fonction qui retourne Result ?","acceptedAnswer":{"@type":"Answer","text":"L'opérateur ? appliqué à un Result extrait la valeur Ok(T) si succès, ou propage automatiquement l'erreur Err(E) à la fonction appelante si échec. Cela évite d'écrire des blocs match répétitifs et rend le code plus lisible tout en garantissant que les erreurs sont correctement propagées."}},{"@type":"Question","name":"Quelle méthode utiliser pour fournir une valeur par défaut si un Option est None ?","acceptedAnswer":{"@type":"Answer","text":"unwrap_or() retourne la valeur contenue dans Some si elle existe, sinon retourne la valeur par défaut fournie en argument. unwrap_or_default() utilise le trait Default pour obtenir une valeur par défaut. Ces méthodes sont plus sûres que unwrap() car elles ne paniquent jamais."}},{"@type":"Question","name":"Comment créer un type d'erreur personnalisé en Rust ?","acceptedAnswer":{"@type":"Answer","text":"Pour créer un type d'erreur personnalisé, il faut définir un enum ou struct et implémenter les traits std::fmt::Display (pour l'affichage) et std::error::Error (pour l'interopérabilité). L'attribut derive peut automatiser Debug. Cette approche permet des erreurs typées et informatives."}},{"@type":"Question","name":"Quelle est la signature de retour correcte pour une fonction main() qui peut échouer ?","acceptedAnswer":{"@type":"Answer","text":"main() peut retourner Result<(), E> où E implémente std::error::Error. Si main retourne Err, le programme affiche l'erreur et termine avec un code de sortie non nul. Cela permet d'utiliser l'opérateur ? directement dans main pour propager les erreurs proprement."}},{"@type":"Question","name":"Que fait la méthode map() sur un Option ?","acceptedAnswer":{"@type":"Answer","text":"map() applique une fonction à la valeur contenue dans Some et retourne un Option avec le résultat. Si l'Option est None, map() retourne None sans appeler la fonction. C'est un pattern fonctionnel qui permet de transformer des valeurs optionnelles sans écrire de conditions explicites."}},{"@type":"Question","name":"Quelle méthode utiliser pour convertir un Option en Result ?","acceptedAnswer":{"@type":"Answer","text":"ok_or() convertit Some(T) en Ok(T) et None en Err(E) avec l'erreur fournie. ok_or_else() fait la même chose mais accepte une closure pour créer l'erreur paresseusement, évitant de construire l'erreur si l'Option contient Some."}},{"@type":"Question","name":"Comment l'opérateur ? gère-t-il la conversion entre différents types d'erreurs ?","acceptedAnswer":{"@type":"Answer","text":"L'opérateur ? utilise le trait From pour convertir automatiquement le type d'erreur source vers le type d'erreur de la fonction. Si impl From for TargetError existe, la conversion est automatique. Cela permet de propager des erreurs de types différents vers un type d'erreur unifié."}},{"@type":"Question","name":"Quelle est la différence entre and_then() et map() sur Option ?","acceptedAnswer":{"@type":"Answer","text":"map() applique une fonction qui retourne T et encapsule le résultat dans Some. and_then() (aussi appelé flat_map) applique une fonction qui retourne déjà Option, évitant ainsi le double encapsulage Option>. and_then() est utile pour chaîner des opérations qui peuvent elles-mêmes échouer."}},{"@type":"Question","name":"Que se passe-t-il si on utilise l'opérateur ? sur un Result dans une fonction qui retourne Option ?","acceptedAnswer":{"@type":"Answer","text":"Le code ne compile pas car l'opérateur ? nécessite que le type de retour de la fonction soit compatible avec le type sur lequel il est appliqué. Une fonction retournant Option ne peut pas utiliser ? sur un Result directement. Il faut d'abord convertir le Result en Option avec ok() ou err()."}},{"@type":"Question","name":"Quelle méthode permet d'exécuter du code uniquement si un Result est Err ?","acceptedAnswer":{"@type":"Answer","text":"map_err() applique une fonction uniquement sur la variante Err, permettant de transformer ou enrichir l'erreur. Si le Result est Ok, la valeur est retournée inchangée. C'est utile pour ajouter du contexte à une erreur ou la convertir vers un autre type."}},{"@type":"Question","name":"Pourquoi Rust n'utilise-t-il pas d'exceptions pour la gestion des erreurs ?","acceptedAnswer":{"@type":"Answer","text":"Rust évite les exceptions car elles ont un coût caché (stack unwinding), rendent le flux de contrôle implicite, et peuvent être ignorées accidentellement. Result force une gestion explicite des erreurs à la compilation, rendant le code plus prévisible et sans surcoût si l'erreur n'est pas levée."}},{"@type":"Question","name":"Quelle est la différence entre panic! et retourner une erreur avec Result ?","acceptedAnswer":{"@type":"Answer","text":"panic! arrête l'exécution du thread immédiatement (unrecoverable error), tandis que Result permet à l'appelant de gérer l'erreur (recoverable error). panic! est réservé aux bugs et états impossibles, Result aux erreurs attendues comme fichier non trouvé ou entrée invalide."}},{"@type":"Question","name":"Comment récupérer la valeur d'un Result tout en fournissant une fonction de récupération en cas d'erreur ?","acceptedAnswer":{"@type":"Answer","text":"unwrap_or_else() accepte une closure qui reçoit l'erreur et retourne une valeur de remplacement. Contrairement à unwrap_or() qui évalue toujours la valeur par défaut, unwrap_or_else() n'exécute la closure que si nécessaire, permettant une récupération paresseuse et personnalisée."}},{"@type":"Question","name":"Comment combiner plusieurs Result pour ne continuer que si tous réussissent ?","acceptedAnswer":{"@type":"Answer","text":"Utiliser l'opérateur ? successivement permet de chaîner les opérations : si l'une échoue, l'erreur est propagée immédiatement. On peut aussi utiliser and_then() pour chaîner des opérations dépendantes. Pour collecter plusieurs Result, la méthode collect() sur un itérateur de Result retourne Result, E>."}}]}