Formation aux bases de Rust

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

Détaille 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 reproductible et fonctionnel.

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

Présente Cargo comme l'outil de construction et le 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 les erreurs panic vs récupérables. Prépare les étudiants pour le type Result abordé dans les chapitres suivants.

Leçon 2 • Constructions 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, les flottants, les booléens, les caractères, les tuples et les tableaux. Les étudiants apprennent l'inférence de type, 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 montre comment les valeurs se déplacent entre les portées. Les étudiants retracent 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 courantes.

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

Examine 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 des blocs impl, distinguant les méthodes des fonctions associées. Établit la base des 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 tuple et unité, 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 modèles avancés

Étend le filtrage par motif à let, aux paramètres de fonction et aux chaînes if-let. Les étudiants écrivent un 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 modèles 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 objets trait

Oppose le dispatch statique à dyn Trait pour le polymorphisme à l'exécution. Les étudiants choisissent entre les génériques et les objets trait 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 en tant qu'éléments de base essentiels. Les étudiants dérivent ou implémentent manuellement ces traits pour s'intégrer à l'écosystème de Rust.

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

Introduit les traits en tant que contrats de comportement partagé et montre comment les implémenter pour des types personnalisés. Relie aux traits les plus courants de la bibliothèque standard.

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

Présente des crates populaires qui réduisent le code passe-partout de la gestion des 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 détail

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'erreur personnalisés

Guide les étudiants à travers la définition d'énumérations d'erreur 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 des erreurs

Montre comment ? propage les erreurs dans la pile d'appels, réduisant le code passe-partout. Les étudiants refactorisent des blocs match verbeux en fonctions concises et lisibles propageant les erreurs.

Leçon 1 • Aperçu des collections standard

Présente Vec, HashMap, HashSet, BTreeMap et VecDeque avec leurs caractéristiques de performance. Les étudiants sélectionnent la bonne collection 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 les traits 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 • Conscience de la performance et de l'allocation

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 d'Async/Await

Présente le trait Future, les fonctions asynchrones et le mot-clé await pour les entrées-sorties non bloquantes. Les étudiants comprendront la différence entre l'asynchrone et les threads et quand préférer l'une ou l'autre approche.

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

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

Leçon 3 • Runtimes asynchrones et modèles pratiques

Présente les runtimes asynchrones, le lancement 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

Spawn des threads du système d'exploitation avec std::thread et explique comment Send et Sync imposent la sécurité des threads. Les étudiants comprennent pourquoi Rust empêche les conditions de course au niveau du type.