Programming Rust

1. Le système de propriété de Rust : sécurité mémoire sans ramasse-miettes

Le pari audacieux de Rust est que, malgré ces contraintes, vous trouverez le langage suffisamment flexible pour presque toutes les tâches, et que les bénéfices — l’élimination de nombreuses classes de bugs liés à la gestion mémoire et à la concurrence — justifieront pleinement les adaptations nécessaires à votre style de programmation.

Propriété et emprunts. Le système de propriété de Rust est une approche innovante de la gestion mémoire qui garantit la sécurité sans recourir à un ramasse-miettes. Chaque valeur possède un unique propriétaire, et la propriété peut être transférée (mouvement) entre variables. Lorsqu’une valeur sort de portée, Rust libère automatiquement sa mémoire.

Références et durées de vie. Rust permet d’emprunter des références à des valeurs, qui peuvent être partagées (&T) ou mutables (&mut T). Le vérificateur d’emprunts applique des règles strictes pour éviter les conditions de concurrence et les erreurs d’utilisation après libération :

• Une seule référence mutable OU plusieurs références partagées à la fois
• Les références ne doivent jamais dépasser la durée de vie de leur référent

Ces règles sont vérifiées à la compilation, éliminant ainsi toute une catégorie de bugs sans coût d’exécution.

2. Structs et enums : les briques pour créer vos propres types

Comme partout ailleurs dans le langage, si une fermeture devait déplacer une valeur d’un type copiable, comme i32, elle copie la valeur à la place.

Structs pour regrouper des données. Les structs en Rust permettent de créer des types personnalisés en regroupant des données liées. Elles se déclinent en trois formes :

• Structs à champs nommés : les plus courantes, avec des champs identifiés
• Structs en tuples : champs non nommés, utiles pour des enveloppes simples
• Structs unitaires : sans champs, pratiques pour implémenter des traits

Enums pour les variantes. Les enums en Rust sont plus puissants que dans beaucoup d’autres langages, car ils définissent un type pouvant prendre plusieurs formes. Chaque variante peut contenir des données, ce qui rend les enums idéaux pour représenter des états ou des résultats multiples.

Le système de correspondance de motifs, notamment avec l’expression match, rend la manipulation des enums à la fois ergonomique et sûre.

3. Traits : définir des comportements partagés

Les traits sont la réponse de Rust aux interfaces ou classes abstraites.

Définir un comportement commun. Les traits en Rust définissent un ensemble de méthodes que les types peuvent implémenter, à l’image des interfaces dans d’autres langages. Ils permettent d’abstraire des comportements partagés, favorisant le polymorphisme et la réutilisation du code.

Objets traits et génériques. Rust propose deux principales façons d’utiliser les traits :

1. Objets traits : pour un polymorphisme dynamique avec un léger coût en performance
2. Traits génériques : abstractions sans coût grâce à la monomorphisation

Les traits peuvent aussi contenir des types associés et des implémentations par défaut, ce qui en fait un outil puissant pour concevoir un code flexible et réutilisable.

4. Gestion des erreurs : résultats et panics

Rust ne possède pas d’exceptions. À la place, les fonctions susceptibles d’échouer ont un type de retour qui l’indique.

Résultats pour les erreurs attendues. Rust utilise le type Result<T, E> pour gérer les erreurs prévisibles. Cet enum comporte deux variantes :

• Ok(T) : contient le résultat réussi
• Err(E) : contient les informations d’erreur

L’opérateur ? offre une syntaxe concise pour propager les erreurs, rendant la gestion explicite et claire.

Panics pour les erreurs inattendues. Pour les erreurs imprévues ou les situations où la récupération est impossible, Rust utilise les panics. Ceux-ci déroulent la pile, appellent les destructeurs et libèrent les ressources. Ils interviennent notamment pour :

• Les erreurs de programmation (ex. accès hors limites)
• Les situations où continuer est impossible ou dangereux

Cette double approche encourage à gérer proprement les erreurs attendues tout en offrant un mécanisme pour les cas irrécupérables.

5. Modules et crates : organiser et partager le code

Les programmes Rust sont composés de crates.

Modules pour organiser le code. Les modules en Rust permettent de structurer le code à l’intérieur d’une crate. Ils peuvent être :

• Définis dans un seul fichier
• Répartis sur plusieurs fichiers
• Imbriqués dans d’autres modules

Les modules contrôlent la visibilité des éléments, vous permettant de définir des interfaces publiques tout en cachant les détails d’implémentation.

Crates pour partager le code. Les crates sont l’unité de compilation et de distribution en Rust :

• Crates bibliothèques : fournissent des fonctionnalités à d’autres crates
• Crates binaires : produisent des exécutables

Le gestionnaire de paquets Cargo facilite la gestion des dépendances, la compilation des projets et la publication sur crates.io, le registre communautaire de Rust.

6. Itérateurs : abstractions puissantes pour les séquences

Les itérateurs de Rust ont été conçus pour que le compilateur puisse les traduire en un code machine optimal.

Évaluation paresseuse. Les itérateurs en Rust sont paresseux, c’est-à-dire qu’ils n’effectuent le travail que lorsqu’ils sont consommés. Cela permet d’enchaîner efficacement les opérations sans créer de collections intermédiaires.

Méthodes puissantes. Le trait Iterator offre un riche ensemble de méthodes pour manipuler les séquences :

• Adaptateurs : transforment les itérateurs (ex. map, filter, zip)
• Consommateurs : produisent les résultats finaux (ex. collect, fold, sum)

Ces méthodes rendent souvent le code plus lisible et performant que les boucles explicites.

Abstraction sans coût. Grâce aux optimisations du compilateur, les chaînes d’itérateurs se compilent souvent en un code aussi efficace que des boucles écrites à la main, offrant des abstractions de haut niveau sans pénalité de performance.

7. Fermetures : types fonctionnels flexibles et efficaces

Les fermetures Rust sont conçues pour être rapides : plus rapides que les pointeurs de fonction, suffisamment pour être utilisées dans du code très sensible à la performance.

Syntaxe et capture. Les fermetures en Rust sont des fonctions anonymes capables de capturer des valeurs de leur environnement. Leur syntaxe est concise et elles peuvent capturer par :

• Référence : emprunt des valeurs
• Référence mutable : emprunt mutable des valeurs
• Valeur : prise de possession des valeurs (avec le mot-clé move)

Traits des fermetures. Rust définit trois traits pour les fermetures :

1. Fn : peut être appelée plusieurs fois sans modifier les valeurs capturées
2. FnMut : peut modifier les valeurs capturées
3. FnOnce : consomme les valeurs capturées, ne peut être appelée qu’une fois

Ces traits offrent un contrôle précis sur le comportement des fermetures et permettent des implémentations efficaces.

8. Concurrence : parallélisme sûr et performant

Un programme Rust concurrent qui évite le code non sécurisé est par construction exempt de conditions de concurrence.

Concurrence sans peur. Les systèmes de propriété et de types de Rust empêchent les conditions de concurrence à la compilation, rendant la programmation concurrente bien plus sûre que dans beaucoup d’autres langages.

Primitives de threading. Rust propose plusieurs outils pour la programmation concurrente :

• std::thread : création de threads au niveau système
• std::sync : primitives de synchronisation (ex. Mutex, Arc)
• Canaux : pour la communication entre threads

Async/await. Rust supporte aussi la programmation asynchrone avec la syntaxe async/await, permettant de gérer efficacement de nombreuses tâches concurrentes sans le surcoût des threads système.

9. Pointeurs intelligents : gestion avancée de la mémoire

Rc et Arc : propriété partagée

Au-delà des pointeurs bruts. Rust offre plusieurs types de pointeurs intelligents qui ajoutent des fonctionnalités aux pointeurs bruts :

• Box<T> : allocation sur le tas
• Rc<T> : comptage de références pour propriété partagée
• Arc<T> : comptage atomique de références (sécurisé en concurrence)
• RefCell<T> : mutabilité intérieure

Sécurité et commodité. Ces pointeurs intelligents fournissent des abstractions sûres pour des patterns courants en programmation système, tels que :

• Le dispatch dynamique
• La propriété partagée
• La mutabilité intérieure

Ils permettent de gérer des scénarios mémoire complexes tout en conservant les garanties de sécurité de Rust.