Formation Rust intermédiaire et avancée

Leçon 1 • Règles de propriété et sémantique de déplacement

Couvre l'invariant du propriétaire unique, les types à déplacement vs. copie, et l'ordre de libération. Établit les fondations de sécurité mémoire dont dépend l'ensemble du cours.

Leçon 2 • Modèles de mutabilité intérieure

Explique Cell, RefCell, et leur vérification d'emprunt à l'exécution pour les cas où les règles à la compilation sont trop restrictives. Fait le pont entre les fondamentaux de la propriété et les modèles avancés d'état partagé.

Leçon 3 • Tranches, références et types de chaînes

Distingue les types str, String et tranche ainsi que leur sémantique de référence. Renforce les concepts d'emprunt par la manipulation pratique de chaînes et de tableaux.

Leçon 4 • Règles d'emprunt et de référence

Enseigne les références partagées et exclusives, les règles d'aliasing et les retours du vérificateur d'emprunt. Prépare directement les étudiants aux annotations de durée de vie dans les sections suivantes.

Leçon 1 • Types associés et familles de types

Distingue les types associés des paramètres génériques et montre quand chacun est approprié. Prépare les étudiants à lire et à écrire correctement les traits d'itérateur et d'opérateur.

Leçon 2 • Types génériques et monomorphisation

Couvre les structures, énumérations et fonctions génériques ainsi que les compromis de coût de la monomorphisation. Fournit le vocabulaire nécessaire pour comprendre les limites de trait et la spécialisation.

Leçon 3 • Objets trait et dispatch dynamique

Explique dyn Trait, les vtables, les règles de sécurité des objets et les implications de performance. Équipe les étudiants pour choisir délibérément entre dispatch statique et dynamique.

Leçon 4 • Limites de trait et clauses Where

Enseigne les limites en ligne, les clauses where et les limites de trait d'ordre supérieur pour des API flexibles. Permet directement les modèles de trait avancés couverts dans les sections suivantes.

Leçon 1 • Panique, déroulement et récupération

Distingue les erreurs récupérables des paniques, explique le déroulement vs. l'arrêt brutal et couvre catch_unwind. Complète le tableau de la gestion des erreurs avec des stratégies de sécurité pour les cas limites.

Leçon 2 • Bibliothèques d'erreur et ergonomie

Présente thiserror pour dériver des types d'erreur et anyhow pour les erreurs au niveau application. Enseigne quand utiliser chaque approche selon le contexte (bibliothèque vs. application).

Leçon 3 • L'opérateur point d'interrogation

Explique comment ? est désucré, les conversions From et la sémantique de retour anticipé en détail. Permet aux étudiants d'écrire du code de propagation concis à travers plusieurs types d'erreur.

Leçon 4 • Combinateurs Result et Option

Couvre map, and_then, unwrap_or et les combinateurs associés pour une gestion ergonomique des erreurs. Établit des modèles idiomatiques avant d'introduire l'opérateur point d'interrogation.

Leçon 1 • Trait Iterator et évaluation paresseuse

Implémente le trait Iterator à partir de zéro et explique le chaînage paresseux d'adaptateurs. Montre comment les abstractions sans coût éliminent les allocations intermédiaires.

Leçon 2 • Capture de fermeture et traits Fn

Explique Fn, FnMut, FnOnce, la capture par référence vs. par déplacement, et la taille des fermetures. Fournit la connaissance des traits nécessaire pour passer des fermetures à travers les frontières d'API.

Leçon 3 • Itérateurs et adaptateurs personnalisés

Construit des itérateurs personnalisés avec état et des structures d'adaptateur qui encapsulent des itérateurs existants. Renforce les compétences en propriété et durée de vie tout en étendant l'écosystème d'itérateurs.

Leçon 4 • Adaptateurs d'itérateur courants

Couvre map, filter, flat_map, zip, enumerate et take en profondeur avec des exemples réels. Développe l'aisance avec le vocabulaire des adaptateurs utilisé dans tout le code Rust idiomatique.

Leçon 1 • Combinaison de pointeurs intelligents

Montre Rc<RefCell<T>> et Arc<Mutex<T>> pour l'état mutable partagé. Connecte la mutabilité intérieure du chapitre 1 aux scénarios avec plusieurs propriétaires.

Leçon 2 • Implémentation de pointeurs intelligents personnalisés

Construit un pointeur intelligent personnalisé en implémentant Deref, DerefMut et Drop. Approfondit la compréhension du fonctionnement interne des pointeurs de la bibliothèque standard.

Leçon 3 • Dispositions mémoire et allocateurs

Examine la disposition des structures, le remplissage, l'alignement et l'interface de l'allocateur global. Équipe les étudiants pour optimiser l'utilisation de la mémoire et intégrer des allocateurs personnalisés.

Leçon 4 • Comptage de références avec Rc et Arc

Compare Rc pour la propriété partagée monothread et Arc pour la propriété partagée multi-thread. Prépare les étudiants à la programmation concurrente en introduisant les contraintes de sécurité des threads.

Leçon 1 • Opérations atomiques et modèles sans verrouillage

Explique les types atomiques, l'ordonnancement mémoire et la comparaison-échange pour les algorithmes sans verrouillage. Prépare les étudiants à raisonner sur les modèles mémoire matériels dans le code critique pour la performance.

Leçon 2 • Itérateurs parallèles et parallélisme de données

Introduit le parallélisme de données via des modèles d'itérateurs parallèles et des ordonnanceurs de vol de travail. Connecte les compétences en itérateurs du chapitre 4 à l'optimisation de performance multi-cœur.

Leçon 3 • Passage de messages avec les canaux

Implémente des modèles producteur-consommateur en utilisant les canaux mpsc et explique la contre-pression. Fournit une alternative sûre à l'état partagé pour la communication inter-threads.

Leçon 4 • Primitives de synchronisation d'état partagé

Couvre Mutex, RwLock, Condvar et Barrier pour coordonner l'accès des threads aux données partagées. S'appuie sur Arc du chapitre 5 pour implémenter des structures de données concurrentes sûres.

Leçon 1 • Syntaxe async et await

Couvre async fn, les blocs async, .await et leur composition en pipelines plus grands. Développe une aisance pratique avant d'introduire les détails de l'exécuteur et du runtime.

Leçon 2 • E/S asynchrones et réseau

Implémente des clients et serveurs TCP asynchrones en utilisant des E/S non bloquantes et des flux asynchrones. Applique les connaissances de l'exécuteur à des scénarios réels de programmation réseau.

Leçon 3 • Modèles asynchrones et pièges

Aborde les erreurs asynchrones courantes : appels bloquants dans un contexte asynchrone, sécurité d'annulation et limites Send. Équipe les étudiants pour déboguer et optimiser le code asynchrone en production.

Leçon 4 • Futures et le trait Future

Explique le trait Future, Poll, Waker et la transformation en machine à états des fonctions asynchrones. Fournit la base conceptuelle pour tous les modèles asynchrones qui suivent.

Leçon 1 • Le mot-clé unsafe et les superpouvoirs

Définit les cinq opérations unsafe, le contrat unsafe et le principe de surface unsafe minimale. Établit le modèle mental pour tous les sujets unsafe ultérieurs.

Leçon 2 • Implémentation d'abstractions unsafe

Construit des abstractions sûres sur du code unsafe, y compris un tampon minimal de type Vec. Montre comment encapsuler des invariants afin que les appelants n'aient jamais besoin d'unsafe.

Leçon 3 • Exposition de Rust à C et audit d'unsafe

Exporte des fonctions Rust pour une consommation C et introduit des outils pour auditer le code unsafe. Complète le tableau du FFI et inculque une discipline de revue de sécurité.

Leçon 4 • Pointeurs bruts et arithmétique de pointeurs

Couvre la création de *const T et *mut T, le déréférencement et les règles d'arithmétique de pointeurs. Prépare les étudiants à la gestion manuelle de la mémoire et à la manipulation de pointeurs FFI.