Points clés
Faire prouver la sûreté mémoire par le compilateur avant la mise en production du code système
Le prix de la liberté. C et C++ permettent aux programmeurs de manipuler directement la mémoire, mais des erreurs comme la lecture au-delà de la fin d’un tableau peuvent entraîner un comportement indéfini: le langage n’impose aucune exigence quant à ce qui se passe alors. Un minuscule exemple en C écrit au-delà d’un tableau d’un seul élément et, sur une machine, affiche un étrange avertissement concernant un fichier de mots de passe avant de planter. Des failles similaires ont permis des attaques. La promesse centrale de Rust est que le code sûr qui passe ses vérifications ne peut pas provoquer de comportement indéfini, par exemple des pointeurs pendants ou une double libération.
La sûreté a ses limites. Rust ne prévient pas toutes les erreurs, et le code unsafe peut enfreindre les règles. Mais par défaut, les vérifications de la mémoire et des courses de données ont lieu à la compilation, sans ramasse-miettes ni mécanisme de sûreté systématique à l’exécution. Les programmeurs système peuvent ainsi viser la vitesse et le contrôle sans que chaque erreur de pointeur devienne un pari à l’exécution.
Le compromis distinctif ne consiste pas simplement à choisir la sûreté plutôt que la vitesse. Il s’agit de transférer une partie du travail de preuve des tests et des incidents en production vers la compilation. Cela rappelle l’analyse statique en ingénierie de la sécurité : un outil peut exclure une catégorie de défaillances, mais il ne peut pas certifier que le programme remplit correctement son objectif. Un programme Rust peut toujours mal gérer les autorisations, analyser incorrectement des données malveillantes ou contenir du code unsafe défectueux. Il faut donc comprendre la promesse au sens strict : Rust sûr élimine de vastes risques liés à la sûreté mémoire, mais ne dispense ni de modéliser les menaces, ni de tester, ni de réviser le code.
Transférer explicitement la propriété plutôt que copier les données ou se fier aux conventions
Un seul propriétaire, un nettoyage prévisible. Chaque valeur Rust a un propriétaire responsable de sa durée de vie. Lorsque ce propriétaire sort de portée, sa valeur est détruite, ainsi que les ressources dont elle est propriétaire. Un vecteur est propriétaire de ses éléments; une structure est propriétaire de ses champs; les propriétés imbriquées forment un arbre qui rend le nettoyage prévisible.
Les déplacements rendent les coûts visibles. L’affectation d’un `String` ou d’un `Vec` déplace généralement son petit en-tête et transfère la responsabilité, au lieu de copier l’allocation sur le tas. L’ancienne variable devient inutilisable, ce qui empêche deux propriétaires de libérer accidentellement le même tampon. Lorsqu’une véritable copie indépendante est souhaitée, `.clone()` rend ce coût explicite. Les valeurs simples comme les entiers peuvent être marquées `Copy`, car la duplication de leurs bits duplique la valeur sans dupliquer une ressource externe. `Rc` et `Arc` permettent la propriété partagée lorsqu’un propriétaire unique est peu pratique, au moyen du comptage de références.
La propriété intègre la gestion des ressources à l’interface d’une valeur, à la manière des types linéaires en théorie des langages de programmation : une ressource est consommée ou transférée plutôt que dupliquée silencieusement. Cette clarté est particulièrement précieuse pour les fichiers, les tampons et les verrous, dont le nettoyage a des conséquences qui dépassent la mémoire. Le revers est une contrainte de conception. Un modèle de domaine en forme de graphe peut nécessiter des identifiants, des pointeurs partagés ou un autre flux de données plutôt que des liens croisés sans restriction. Cette contrainte peut révéler des aspects de l’architecture, mais elle peut aussi rendre un prototype simple plus exigeant que ne le justifie son problème initial.
Considérer les références comme des permissions: plusieurs lecteurs ou un seul rédacteur exclusif
Emprunter sans prendre possession. Une référence donne un accès temporaire à une valeur sans en être propriétaire. Rust autorise plusieurs références partagées, notées `&T`, pour la lecture, ou une seule référence mutable exclusive, notée `&mut T`, pour lire et écrire. Ces permissions ne peuvent pas se chevaucher d’une manière qui permettrait de modifier une valeur alors qu’un autre chemin d’accès l’utilise encore.
Les durées de vie rendent les relations explicites. Le compilateur vérifie que les références ne survivent pas aux valeurs qu’elles désignent. Les durées de vie sont des contraintes à la compilation, pas des minuteries à l’exécution ni de la mémoire supplémentaire. Elles détectent aussi l’invalidation de collections: le code ne peut pas emprunter un vecteur de façon mutable pour l’agrandir tout en empruntant simultanément ses éléments sous forme de tranche, car sa croissance pourrait provoquer une réallocation et invalider cette tranche. La même règle d’exclusivité permet le partage sûr entre threads.
La règle « plusieurs lecteurs ou un rédacteur » offre un moyen concis de raisonner sur les alias, c’est-à-dire la situation où plusieurs chemins peuvent accéder aux mêmes données. Elle relie la correction locale du programme à la concurrence : une course de données exige un accès partagé à une mémoire mutable sans synchronisation, précisément la combinaison que ces références restreignent. Cette règle ne constitue pas une conception complète de la concurrence. Les verrous peuvent toujours provoquer des interblocages, et les programmes synchronisés peuvent encore se comporter différemment selon le minutage. Rust bloque un mécanisme dangereux, pas toutes les interactions surprenantes.
Modéliser les alternatives avec des énumérations afin de traiter explicitement chaque cas valide
Représenter directement les possibilités. Une énumération Rust peut décrire des alternatives contenant des données différentes, et pas seulement une liste de constantes nommées. `Option<T>` signifie qu’une valeur est présente ou absente; `Result<T, E>` signifie qu’une opération a réussi ou échoué. Une valeur JSON peut être représentée par une énumération comportant des variantes pour null, les booléens, les nombres, les chaînes de caractères, les tableaux et les objets.
Les motifs rendent l’inspection sûre. Une expression `match` vérifie quelle variante est présente et en extrait les données. Le compilateur exige que tous les cas possibles soient couverts, ou qu’une branche de repli explicite soit prévue. On évite ainsi de lire un champ qui pourrait ne pas exister. Le livre compare une représentation JSON Rust de huit lignes à l’imposant mécanisme de balisage, de stockage et de nettoyage nécessaire pour une classe C++ comparable fondée sur une union.
Les énumérations donnent une structure à l’incertitude. Au lieu de disperser dans le programme les vérifications de nullité, les balises de type et les suppositions, les différentes possibilités sont réunies dans une même définition, et le compilateur signale le code qui n’a pas pris en compte un nouveau cas. Cela rappelle les types algébriques des langages fonctionnels et les unions balisées des schémas de bases de données. La limite est délibérée : l’ajout d’une variante peut casser les correspondances exhaustives en aval. Les énumérations sont donc idéales lorsque les changements doivent imposer une révision de l’ensemble du programme, mais moins adaptées à une extension ouverte par des utilisateurs indépendants.
Utiliser les traits pour exprimer des capacités sans payer le coût de la répartition dynamique
Décrire ce qu’un type sait faire. Un trait nomme une capacité, comme écrire des octets ou produire des éléments d’itérateur. Le code générique peut exiger uniquement les traits dont il se sert. Par exemple, une même fonction « dire bonjour » peut écrire dans un fichier, un flux réseau ou un vecteur d’octets, car chacun implémente `Write`.
Choisir délibérément le mode de répartition. Le compilateur spécialise les fonctions génériques pour chaque type concret, processus appelé monomorphisation. Les appels peuvent être intégrés et éviter la recherche de méthode à l’exécution. Un objet de trait, tel que `&mut dyn Write`, porte des informations de type à l’exécution et répartit les appels par l’intermédiaire d’une table de méthodes. Ce coût est utile lorsqu’une collection doit contenir plusieurs types concrets. Les traits permettent aussi les méthodes d’extension et les conventions partagées entre bibliothèques, tandis que la règle des orphelins empêche les implémentations conflictuelles d’un trait étranger pour un type étranger.
Les traits rendent les interfaces explicites sans imposer de hiérarchies d’héritage. Ils rendent également les choix de performance lisibles : la répartition statique favorise la spécialisation, tandis que les objets de trait favorisent l’hétérogénéité et la souplesse. Aucune de ces options n’est supérieure en toutes circonstances. La spécialisation peut augmenter la taille du code compilé, tandis que la répartition dynamique ajoute une indirection et peut limiter les optimisations. C’est un bon exemple de la façon dont Rust rend un compromis visible dans les types, au lieu de le dissimuler derrière une abstraction apparemment neutre.
Rendre les échecs visibles dans les signatures de fonction, puis les propager avec `?`
Distinguer les bogues des problèmes courants. Rust utilise les paniques pour les situations qui signalent un bogue du programme, comme un accès hors limites ou l’échec d’une assertion. Les problèmes externes, tels que des fichiers illisibles ou des entrées invalides, sont généralement représentés par `Result`: soit `Ok(value)`, soit `Err(error)`. Le type de retour indique aux appelants qu’un échec est possible.
Transmettre clairement les erreurs. L’opérateur `?` renvoie la valeur en cas de réussite ou quitte la fonction courante en transmettant l’erreur. Lorsque les types d’erreur diffèrent, Rust peut les convertir au moyen d’implémentations de `From`. Une fonction de traitement de fichiers peut ainsi propager les erreurs de lecture et d’analyse sans dissimuler l’une ou l’autre possibilité. N’utilisez `expect` ou `unwrap` que si l’échec signale réellement une situation qui doit interrompre le programme, et non comme raccourci pour gérer des entrées ordinaires incorrectes.
Représenter l’échec par une valeur plutôt que par un saut invisible dans le flot de contrôle facilite le raisonnement local : une signature indique à l’appelant s’il doit traiter une erreur ou la transmettre. Cela s’apparente aux systèmes d’effets explicites, dans lesquels le type d’une fonction annonce un comportement important. Le coût tient à la conception des types d’erreur et de leurs conversions, surtout lorsqu’une fonction combine des opérations sans rapport entre elles. Une erreur fourre-tout simplifie le raccordement, mais renseigne moins l’appelant. L’objectif utile n’est pas une complexité maximale des types, mais une précision suffisante pour que la couche suivante puisse prendre une décision fondée.
Composer des chaînes d’itérateurs paresseuses, sans oublier qu’elles ne s’exécutent qu’une fois consommées
Construire les transformations par étapes. Un itérateur produit des valeurs à la demande. Des adaptateurs comme `map` et `filter` créent de nouveaux itérateurs qui transforment ou sélectionnent ces valeurs, tandis que des consommateurs comme `collect`, `fold` ou une boucle `for` les demandent effectivement. Une chaîne peut supprimer les espaces en début et en fin de ligne, écarter les entrées indésirables et recueillir les résultats sans créer de collections intermédiaires.
La paresse n’est pas du travail perdu. Dans l’exemple des nombres triangulaires du livre, Rust peut intégrer un `fold` et sa fermeture, puis optimiser le calcul pour en faire une petite expression arithmétique. Mais un adaptateur qui a des effets de bord ne fait rien si aucun consommateur ne demande d’élément. Les opérations sur les collections rendent aussi la propriété explicite: parcourir une collection par valeur la consomme, tandis que la parcourir par référence emprunte ses éléments. De même, les API d’entrée évitent de répéter les recherches dans une table.
Les chaînes d’itérateurs fournissent un vocabulaire pour décrire le flux des données : chaque étape indique son rôle, et l’évaluation paresseuse permet au compilateur de fusionner plusieurs étapes en une seule boucle. Cela ressemble à la planification des requêtes, où une base de données peut combiner filtres et projections au lieu de matérialiser chaque résultat intermédiaire. Le risque tient à l’accumulation, qui nuit à la lisibilité. Une longue chaîne comportant des effets de bord cachés ou des fermetures complexes peut être plus difficile à déboguer qu’une boucle. La paresse favorise les performances et la composition, mais ne dispense pas de vérifier que la chaîne est effectivement consommée.
Choisir une structure de concurrence avant de recourir à un état mutable partagé
Commencer par isoler les tâches. Le modèle fork-join répartit les tâches indépendantes entre plusieurs threads, puis rassemble leurs résultats. Les canaux transmettent plutôt des valeurs dont la propriété est transférée entre les étapes, comme dans le pipeline d’index inversé du livre. Ces deux approches rendent le flux des données plus facile à comprendre que l’accès partagé sans restriction. Les traits `Send` et `Sync` de Rust indiquent les valeurs qui peuvent être transférées entre threads ou partagées par référence en toute sûreté.
N’utiliser des verrous qu’avec une bonne raison. Un `Mutex` assure un accès exclusif à des données mutables partagées, et un verrou en lecture-écriture autorise plusieurs lecteurs ou un seul rédacteur. Ces outils empêchent les courses de données, mais pas les interblocages ni les bogues logiques dépendant du minutage. Pour le rendu de Mandelbrot, la division de l’image en bandes de taille égale a entraîné une répartition inégale du travail. Rayon a distribué les lignes dynamiquement et utilisé environ 7,75 cœurs sur 8, illustrant l’importance potentielle de l’ordonnancement du travail, au même titre que le nombre de threads. Les canaux synchrones à capacité limitée ajoutent une contre-pression lorsque les producteurs devancent les consommateurs.
La concurrence n’est pas un outil unique, mais un choix sur la façon dont les composants se coordonnent. Le modèle fork-join convient aux calculs indépendants ; le passage de messages, aux pipelines et aux services ; les verrous, aux états véritablement partagés. Cela rappelle la distinction entre les systèmes à parallélisme de données et ceux de style acteur, chacun ayant ses propres goulots d’étranglement. L’exemple de Mandelbrot est particulièrement utile, car il distingue le partage en parts égales de la charge de travail équivalente. Une réserve toutefois : une utilisation élevée des cœurs n’est pas une fin en soi. Les gains réels dépendent du travail séquentiel, de la bande passante mémoire, des entrées-sorties et du coût du regroupement des résultats.
Utiliser l’asynchrone pour de nombreuses tâches en attente, et non pour accélérer les entrées-sorties
Suspendre plutôt que monopoliser un thread. Une future représente un travail qui n’est peut-être pas encore prêt. Son interrogation renvoie soit une valeur calculée, soit `Pending`; un exécuteur l’interroge de nouveau lorsqu’un waker signale une progression. Les fonctions `async` et `await` donnent au code une apparence séquentielle tout en le suspendant lors des opérations qui bloqueraient autrement. Il devient ainsi possible de gérer de nombreuses tâches réseau sans consacrer à chacune un thread complet du système d’exploitation.
Adapter la méthode à la charge de travail. L’asynchrone peut réduire les coûts de mémoire par tâche et d’ordonnancement, surtout pour les serveurs qui gèrent de nombreuses connexions. Il n’accélère pas le travail du réseau ou du disque. De longs calculs peuvent monopoliser un thread de travail asynchrone à moins de céder la main ou d’être déplacés vers un thread bloquant. Un mutex conservé pendant un `await` nécessite également une stratégie de verrouillage asynchrone, afin que la tâche puisse céder la main au lieu de bloquer tout son thread.
Il vaut mieux comprendre l’asynchrone comme une stratégie de gestion des ressources que comme un sortilège de rapidité. Il modifie la représentation de l’attente et permet à un ordonnanceur de réutiliser un thread pendant les entrées-sorties. Cet avantage augmente avec le nombre de tâches principalement inactives ; il peut être minime pour un petit programme ou une charge de travail limitée par le processeur. Le modèle de programmation ajoute aussi ses propres difficultés : annulation, durées de vie des tâches et travail qui monopolise un exécuteur. La décision devrait découler de contraintes mesurées sur les ressources, et non de l’idée que tout appel réseau exige de l’asynchrone.
Limiter le code unsafe et expliciter son contrat caché
Marquer la frontière de la preuve. Les blocs unsafe autorisent des opérations que le compilateur ne peut pas vérifier, notamment le déréférencement de pointeurs bruts et les appels à des fonctions unsafe. Ils ne désactivent pas les vérifications de types ordinaires. Le programmeur doit respecter le contrat de chaque opération, car le non-respect de ce contrat peut provoquer un comportement indéfini, parfois très loin de l’erreur initiale.
Construire une enveloppe sûre. L’exemple de chaîne ASCII du livre vérifie les octets à la construction, puis utilise une conversion unsafe en UTF-8, uniquement parce que l’ASCII est un sous-ensemble valide de l’UTF-8. Son tampon avec trou utilise de la mémoire brute pour accélérer les insertions tout en exposant des méthodes sûres. Pour les bibliothèques C comme libgit2, une enveloppe sûre peut s’appuyer sur la propriété, les durées de vie et `Drop` afin de garantir que les ressources sont initialisées, libérées une seule fois et ne survivent pas à leurs dépendances. Le code unsafe doit aussi nettoyer les ressources de façon sûre en cas de panique lorsque des invariants sont momentanément rompus.
Le rôle le plus productif du code unsafe est de rester un détail d’implémentation restreint, derrière une abstraction sûre. Cela rappelle une base informatique de confiance : une partie limitée du système assume une responsabilité inhabituelle, et la réduire facilite les révisions. Mais restreint ne signifie pas correct. La validité d’une opération unsafe peut dépendre des constructeurs, des appelants, des alias et des chemins de nettoyage à l’échelle d’un module. Des invariants clairs, des tests ciblés et une révision attentive sont essentiels, car le compilateur ne peut pas achever cette preuve.
Garantir la reproductibilité des compilations et la testabilité des interfaces à mesure que le projet grandit
Considérer les outils comme une infrastructure de conception. Cargo crée des projets, résout les dépendances, compile les crates, lance les tests et génère la documentation. Les modules organisent le code au sein d’une crate; les crates empaquettent des bibliothèques ou des exécutables réutilisables. Un `Cargo.toml` décrit les versions compatibles des dépendances, tandis que `Cargo.lock` enregistre les versions exactes utilisées pour produire une compilation reproductible d’un exécutable.
Rendre les exemples exécutables. Rust prend en charge les tests unitaires placés à côté du code d’implémentation, les tests d’intégration qui vérifient l’interface publique d’une bibliothèque et les exemples de la documentation, compilés et exécutés comme des tests. Ces pratiques transforment les API en quelque chose que les utilisateurs peuvent vérifier, plutôt que de simplement lire. Les espaces de travail Cargo permettent à des crates apparentées de partager les artefacts de compilation et un fichier de verrouillage. Ensemble, outils et conventions facilitent la collaboration, tandis que les traits et les types de la bibliothèque standard fournissent aux crates indépendantes des moyens communs d’interopérer.
Le livre présente le gestionnaire de paquets, le dispositif de tests et le générateur de documentation comme des éléments de l’expérience de programmation, et non comme de simples tâches administratives. C’est un choix de conception substantiel : des dépendances reproductibles réduisent une source d’incertitude, et la documentation exécutable vérifie que les exemples correspondent toujours à l’API. Les limites restent importantes. Un fichier de verrouillage ne peut garantir qu’un système d’exploitation ou un service externe se comportera de façon identique, et des tests réussis ne prouvent pas l’absence de défauts. Les outils réduisent l’incertitude ; ils ne l’éliminent pas.
Analyse
Programmer avec Rust se lit avant tout comme une réflexion sur le lieu où doit résider la complexité des systèmes. En C et en C++, la validité des pointeurs, la propriété et la discipline des threads reposent principalement sur les conventions suivies par les programmeurs. Rust transfère une grande partie de cette charge dans les types et les vérifications à la compilation, puis rend les exceptions manifestes au moyen d’opérations unsafe. La propriété, l’emprunt, les énumérations, les traits et les résultats d’erreur ne sont pas des fonctionnalités sans lien entre elles: ensemble, ils rendent visibles, dans les interfaces, les durées de vie des ressources, les droits de mutation, les chemins d’échec et les capacités des types.
Les exemples du livre concrétisent cette conception. Un débordement de tampon peut corrompre le flot de contrôle; la réallocation d’un vecteur peut invalider une tranche empruntée; des lignes de Mandelbrot de charge inégale peuvent gaspiller des cœurs; un consommateur lent dans un pipeline peut entraîner une accumulation en mémoire. Chaque exemple relie une règle abstraite à une défaillance opérationnelle. C’est une stratégie pédagogique efficace, car les restrictions de Rust peuvent autrement sembler arbitraires. Le lecteur constate que le compilateur ne fait pas qu’imposer un style. Il réduit l’ensemble des programmes dont le comportement dépend d’hypothèses invisibles.
Ce compromis n’est pas gratuit. La propriété peut imposer des changements d’architecture, les contraintes des génériques peuvent devenir verbeuses et le code asynchrone soulève des questions d’ordonnancement et de durée de vie. De même, la compilation ne prouve pas la correction de l’application. Les erreurs logiques, les autorisations défectueuses, l’épuisement des ressources et les erreurs dans le code unsafe restent possibles. La thèse la plus forte du livre est donc circonscrite: Rust sûr élimine d’importantes catégories de comportements indéfinis tout en préservant le contrôle de bas niveau, mais le programmeur reste responsable de l’argument général démontrant la correction du système.
Certains exemples et certaines versions de l’écosystème reflètent le contexte de publication du livre, en 2021, tandis que les distinctions conceptuelles demeurent pertinentes. Les lecteurs devraient considérer le code comme un enseignement des principes de conception, et non comme la garantie que chaque version de crate ou exemple d’API est encore à jour. La leçon durable est méthodologique: rendre explicites les coûts et les permissions, choisir délibérément les modèles de coordination et isoler la petite partie du code dont la sûreté repose sur le raisonnement humain.
Résumé des avis
Programmer avec Rust reçoit des avis très largement positifs, notamment pour sa couverture complète des particularités de Rust. Les lecteurs apprécient ses explications approfondies, en particulier sur la gestion de la mémoire, la concurrence et les concepts de programmation système. Beaucoup l’ont trouvé utile aussi bien pour apprendre Rust que comme ouvrage de référence. Le livre est remarqué pour la clarté de son écriture, ses exemples pertinents et ses comparaisons avec le C et le C++. Certains passages sont complexes, mais la plupart des lecteurs jugent le contenu captivant et précieux. Il est vivement recommandé aux programmeurs expérimentés qui souhaitent maîtriser Rust.
Les lecteurs ont aussi lu
Glossaire
propriété (ownership)
Qui contrôle une valeurLa règle de Rust selon laquelle chaque valeur a un propriétaire responsable de sa durée de vie. Lorsque le propriétaire sort de portée ou transfère la valeur, Rust veille à ce que la valeur et les ressources qu’elle possède soient libérées exactement une fois. La propriété peut être transférée entre variables ou structures de données, ce qui rend explicite la gestion des ressources sans nécessiter de ramasse-miettes.
déplacement (move)
Transférer la propriété d’une valeurUn déplacement transfère une valeur qui n’implémente pas Copy d’un emplacement à un autre, sans créer de copie indépendante de son contenu. La source est alors considérée comme non initialisée, et la destination devient responsable de la valeur. Déplacer une String ou un Vec consiste généralement à transférer un petit en-tête, et non son tampon potentiellement volumineux situé sur le tas.
durée de vie (lifetime)
Durée pendant laquelle un emprunt reste valideUne description, vérifiée à la compilation, de la durée pendant laquelle une référence peut être utilisée en toute sécurité. Rust vérifie qu’une référence ne peut pas survivre à la valeur vers laquelle elle pointe et que les types contenant des références respectent la même contrainte. Les durées de vie n’existent pas à l’exécution sous forme de minuteries ou de données de pointeur supplémentaires ; elles expriment des relations dont le compilateur se sert pour rejeter les références pendantes.
objet de trait (trait object)
Implémentation de trait choisie à l’exécutionUn pointeur vers une valeur qui implémente un trait donné, lorsque le type concret n’est pas fixé à la compilation. Un objet de trait tel que &dyn Write contient l’adresse de la valeur et les informations permettant de sélectionner à l’exécution l’implémentation de méthode appropriée. Il permet de créer des collections hétérogènes, avec une répartition dynamique des appels plutôt qu’une spécialisation générique.
monomorphisation
Spécialiser le code générique pour chaque typeProcessus par lequel le compilateur génère du code machine concret pour les fonctions ou les types génériques utilisés avec des types spécifiques. Une fonction générique contrainte par un trait peut ainsi appeler directement l’implémentation appropriée, ce qui permet souvent l’inlining. Cela évite dans de nombreux cas la répartition des appels via un objet de trait, même si générer plusieurs versions peut augmenter la taille du binaire.
Send et Sync
Marqueurs de sécurité pour le transfert entre threadsSend indique que les types concernés peuvent être transférés en toute sécurité vers un autre thread. Sync indique qu’ils peuvent être partagés en toute sécurité entre threads au moyen de références partagées. Rust utilise ces traits dans les API qui franchissent les limites entre threads. La plupart des types héritent de ces propriétés de leurs champs, tandis que des types comme Rc<T> ne les possèdent pas, car leurs compteurs de références ne sont pas mis à jour de manière atomique.
Future
Travail susceptible de s’achever plus tardUne valeur représentant une opération dont le résultat n’est peut-être pas encore disponible. Sa méthode poll renvoie soit un résultat achevé, soit Pending ; dans ce dernier cas, la future prévoit qu’un waker avertira un exécuteur lorsqu’une progression sera peut-être possible. Les fonctions et blocs async produisent des futures qui conservent l’état nécessaire pour reprendre au point d’attente.
Pin
Empêcher le déplacement d’une future après son interrogationUn wrapper autour d’un pointeur qui limite les déplacements possibles de la valeur référencée. Les futures créées par des fonctions ou des blocs async peuvent, après avoir été interrogées, contenir des références vers leur propre état stocké ; les déplacer pourrait donc invalider ces références. L’épinglage permet de les interroger en toute sécurité. Les types qui implémentent Unpin ne nécessitent pas cette restriction de déplacement.
mutabilité intérieure (interior mutability)
Modification par un accès partagéUn moyen contrôlé de modifier une valeur même lorsqu’on y accède par une référence partagée. Cell et RefCell font respecter leurs règles à l’exécution dans du code mono-thread, tandis que Mutex et les types de synchronisation apparentés permettent des modifications partagées entre threads. Cela assouplit les règles ordinaires de mutabilité vérifiées à la compilation ; le wrapper choisi doit donc imposer la discipline d’accès appropriée.
bloc unsafe
Autoriser les opérations non vérifiéesUne région marquée dans laquelle Rust autorise des opérations dont il ne peut pas vérifier la sûreté, comme le déréférencement de pointeurs bruts ou l’appel de fonctions unsafe. Les vérifications ordinaires des types et des emprunts restent en vigueur. Le programmeur doit respecter le contrat documenté de chaque opération ; le violer peut entraîner un comportement indéfini. Les API sûres utilisent souvent de petits blocs unsafe en interne, tout en laissant leurs appelants dans du Rust soumis aux vérifications.
Télécharger le PDF
Télécharger l'EPUB
.epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.