Formation aux bases de Rust

Leçon 1 • Installation et configuration de la chaîne d'outils

Guide l'installation de rustup, la sélection des versions de la chaîne d'outils et la configuration d'un éditeur. Garantit que chaque étudiant dispose d'un environnement de travail reproductible.

Leçon 2 • Le système de construction Cargo

Présente Cargo comme l'outil de construction et gestionnaire de paquets officiel de Rust. Les étudiants créent, construisent et exécutent leur premier projet à l'aide des commandes Cargo.

Leçon 3 • Écrire et exécuter votre premier programme

Guide les étudiants à travers un programme Rust minimal, en expliquant la fonction main, les macros et la sortie de compilation. Relie la syntaxe au modèle de langage plus large.

Leçon 1 • Fonctions et gestion des erreurs de base

Définit des fonctions avec des paramètres typés et des valeurs de retour, et introduit panic vs les erreurs récupérables. Prépare les étudiants au type Result abordé dans les chapitres suivants.

Leçon 2 • Structures de flux de contrôle

Enseigne les constructions if, loop, while et for, y compris leurs formes d'expression. Les étudiants écrivent une logique de branchement et d'itération qui se compile sans avertissements.

Leçon 3 • Variables, mutabilité et masquage

Explique les liaisons let, la règle d'immuabilité par défaut et la sémantique de masquage. Établit l'approche stricte de Rust concernant l'état des variables dès le début du cours.

Leçon 4 • Types scalaires et composés

Couvre les entiers, flottants, booléens, caractères, tuples et tableaux. Les étudiants apprennent l'inférence de types, les annotations explicites et les limites de chaque type.

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

Définit les trois règles de propriété et démontre comment les valeurs se déplacent entre les portées. Les étudiants tracent les transferts de propriété pour prédire quand les valeurs sont libérées.

Leçon 2 • Le type Slice

Couvre les slices de chaînes et les slices de tableaux en tant que types de référence vers des données contiguës. Renforce les concepts d'emprunt avec des vues de données pratiques et couramment utilisées.

Leçon 3 • Annotations de durée de vie

Explique les paramètres de durée de vie comme un moyen d'exprimer les relations de validité des références. Les étudiants annotent des fonctions et des structures pour satisfaire le vérificateur d'emprunt dans des scénarios complexes.

Leçon 4 • Modèles de propriété courants

Passe en revue les modèles idiomatiques tels que le clonage, le retour de valeurs possédées et l'utilisation de Rc pour la propriété partagée. Fait le pont entre la théorie et les décisions de conception pratiques.

Leçon 1 • Méthodes et fonctions associées

Attache un comportement aux structures via les blocs impl, en distinguant les méthodes des fonctions associées. Établit la base pour les implémentations de traits dans le chapitre suivant.

Leçon 2 • Définition et utilisation des structures

Couvre les structures à champs nommés, les structures tuples et les structures unitaires, ainsi que la syntaxe de mise à jour des structures. Les étudiants modélisent des données réelles et comprennent comment la propriété s'applique aux champs des structures.

Leçon 3 • Déstructuration et motifs avancés

Étend le filtrage par motif à let, aux paramètres de fonction et aux chaînes if-let. Les étudiants écrivent du code concis qui gère plusieurs formes de données sans conditionnels imbriqués.

Leçon 4 • Filtrage par motif avec match

Enseigne les expressions match exhaustives, les gardes et les motifs de liaison. Les étudiants déconstruisent des types de données complexes de manière sécurisée et lisible.

Leçon 1 • Dispatch dynamique avec les objets traits

Contraste le dispatch statique avec dyn Trait pour le polymorphisme à l'exécution. Les étudiants choisissent entre les génériques et les objets traits en fonction des besoins de performance et de flexibilité.

Leçon 2 • Fonctions et structures génériques

Introduit les paramètres de type sur les fonctions et les structures, permettant la réutilisation du code entre les types. Les étudiants écrivent des structures de données génériques et comprennent la monomorphisation.

Leçon 3 • Traits courants de la bibliothèque standard

Couvre Display, Debug, Clone, Copy, PartialEq et Iterator comme éléments de base essentiels. Les étudiants dérivent ou implémentent manuellement ces traits pour s'intégrer à l'écosystème Rust.

Leçon 4 • Définition et implémentation de traits

Introduit les traits comme des contrats de comportement partagés et montre comment les implémenter pour des types personnalisés. Fait le lien avec les traits les plus courants de la bibliothèque standard.

Leçon 1 • Utilisation de bibliothèques de gestion d'erreurs

Présente des crates populaires qui réduisent le code standard de gestion d'erreurs et améliorent l'ergonomie. Les étudiants évaluent quand une bibliothèque apporte une valeur ajoutée par rapport aux implémentations manuelles.

Leçon 2 • Result<T, E> en profondeur

Examine les variantes de Result, les combinateurs et les méthodes unwrap. Les étudiants comprennent quand chaque méthode est appropriée et ce qu'elle signale aux appelants.

Leçon 3 • Types d'erreurs personnalisés

Guide les étudiants dans la définition d'énumérations d'erreurs spécifiques au domaine et l'implémentation des traits d'erreur standard. Produit des API avec des informations d'erreur structurées et informatives.

Leçon 4 • L'opérateur ? et la propagation d'erreurs

Montre comment ? propage les erreurs vers le haut de la pile d'appels, réduisant le code standard. Les étudiants refactorisent des blocs match verbeux en fonctions de propagation d'erreurs concises et lisibles.

Leçon 1 • Aperçu des collections standard

Passe en revue Vec, HashMap, HashSet, BTreeMap et VecDeque avec leurs caractéristiques de performance. Les étudiants sélectionnent la collection appropriée pour chaque exigence d'accès et d'ordre.

Leçon 2 • Fermetures et environnements capturés

Définit les fermetures comme des fonctions anonymes qui capturent leur environnement par référence ou par valeur. Les étudiants utilisent Fn, FnMut et FnOnce pour exprimer les capacités des fermetures.

Leçon 3 • Adaptateurs et consommateurs d'itérateurs

Couvre map, filter, flat_map, take, zip et collect comme la boîte à outils d'adaptateurs de base. Les étudiants composent des pipelines paresseux qui s'exécutent seulement lorsqu'ils sont consommés.

Leçon 4 • Performance et conscience des allocations

Analyse les affirmations d'abstraction à coût zéro des itérateurs et les pièges d'allocation courants. Les étudiants profilent des pipelines simples et choisissent entre les itérateurs et les boucles manuelles lorsque cela est justifié.

Leçon 1 • Fondamentaux de l'async/await

Introduit le trait Future, les fonctions async et le mot-clé await pour les E/S non bloquantes. Les étudiants comprennent en quoi l'asynchrone diffère des threads et quand préférer l'un à l'autre.

Leçon 2 • État partagé avec Mutex et Arc

Combine Arc pour la propriété partagée et Mutex pour la mutabilité interne à travers les threads. Les étudiants construisent un compteur thread-safe et comprennent l'empoisonnement de verrou.

Leçon 3 • Exécutants asynchrones et modèles pratiques

Passe en revue les exécutants asynchrones, la création de tâches et les modèles asynchrones courants comme les timeouts et select. Les étudiants exécutent un programme asynchrone complet et gèrent des tâches concurrentes en toute sécurité.

Leçon 4 • Threads et traits Send et Sync

Génère des threads OS avec `std::thread` et explique comment `Send` et `Sync` imposent la sécurité des threads. Les étudiants comprennent pourquoi Rust empêche les situations de concurrence au niveau des types.