Cours intermédiaire et avancé de programmation Rust

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

Couvre l'invariant de possesseur unique, les types par déplacement et par copie, et l'ordre de libération. Établit la base de sécurité mémoire dont dépend tout le cours.

Leçon 2 • Patrons 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 patrons avancés d'état partagé.

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

Fait la distinction entre str, String et les types de tranches 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 messages 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 bornes de trait et la spécialisation.

Leçon 3 • Objets de trait et répartition dynamique

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

Leçon 4 • Bornes de trait et clauses Where

Enseigne les bornes en ligne, les clauses where et les bornes de trait de rang supérieur pour des API flexibles. Permet directement les patrons 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, 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 logicielles d'erreurs et ergonomie

Examine thiserror pour dériver des types d'erreur et anyhow pour les erreurs au niveau des applications. Enseigne quand utiliser chaque approche selon le contexte de bibliothèque ou d'application.

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

Explique comment ? se désucre, les conversions From et la sémantique de retour anticipé en détail. Permet aux étudiants d'écrire du code de propagation concis entre 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 patrons 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 d'adaptateurs paresseux. 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 le dimensionnement des fermetures. Fournit la connaissance des traits nécessaire pour passer des fermetures à travers les frontières des 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 des 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é. Relie la mutabilité intérieure du chapitre 1 aux scénarios à plusieurs possesseurs.

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 possession partagée monothread et Arc pour la possession partagée multithread. Prépare les étudiants à la programmation concurrente en introduisant les contraintes de sécurité des fils d'exécution.

Leçon 1 • Opérations atomiques et patrons sans verrou

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

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

Introduit le parallélisme de données via des patrons d'itérateurs parallèles et des ordonnanceurs à vol de travail. Relie les compétences en itérateurs du chapitre 4 à l'optimisation du rendement multicœur.

Leçon 3 • Passage de messages avec les canaux

Implémente des patrons producteur-consommateur en utilisant des canaux mpsc et explique la contre-pression. Fournit une alternative sûre à l'état partagé pour la communication entre fils d'exécution.

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

Couvre Mutex, RwLock, Condvar et Barrier pour coordonner l'accès des fils d'exécution 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 comment ils se composent en pipelines plus grands. Développe une aisance pratique avant d'introduire les détails de l'exécuteur et de l'environnement d'exécution.

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 • Patrons asynchrones et pièges

Aborde les erreurs asynchrones courantes : appels bloquants dans un contexte asynchrone, sécurité d'annulation et bornes 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 d'état des fonctions asynchrones. Fournit la base conceptuelle pour tous les patrons 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 pour 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 consommation C et introduit des outils pour auditer le code unsafe. Complète le tableau FFI et inculque une discipline de révision 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.