Formation de base en Rust

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

Guide d'installation de rustup, de sélection des versions de la chaîne d'outils et de configuration d'un éditeur. Garantit à chaque étudiant 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, 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 de base des erreurs

Définit des fonctions avec des paramètres typés et des valeurs de retour, et introduit panic par rapport aux erreurs récupérables. Prépare les étudiants pour le 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 tôt dans le cours l'approche stricte de Rust concernant l'état des variables.

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 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 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 tranche (Slice)

Couvre les tranches de chaînes et les tranches de tableaux comme types de référence dans 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 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 des 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éfinir et utiliser des structures

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

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

Étend le filtrage par motif à let, aux paramètres de fonctions 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 • Répartition dynamique avec les objets traits

Met en contraste la répartition 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 rendement et de flexibilité.

Leçon 2 • Fonctions génériques 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 de Rust.

Leçon 4 • Définir et implémenter des traits

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

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

Présente les caisses populaires qui réduisent le code répétitif de gestion des erreurs et améliorent l'ergonomie. Les étudiants évaluent quand une bibliothèque logicielle ajoute de la valeur par rapport aux mises en œuvre 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'erreur personnalisés

Guide les étudiants dans 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 d'erreurs

Montre comment l'opérateur ? propage les erreurs vers le haut de la pile d'appels, réduisant ainsi le code passe-partout de gestion des erreurs. Les étudiants remanient des blocs match verbeux en fonctions concises et lisibles qui propagent les erreurs.

Leçon 1 • Aperçu des collections standard

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

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 boîte à outils d'adaptateurs de base. Les étudiants composent des pipelines paresseux qui ne s'exécutent que lorsqu'ils sont consommés.

Leçon 4 • Sensibilisation au rendement et à l'allocation

Analyse les affirmations d'abstraction à coût nul 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 • Principes fondamentaux d'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é intérieure entre les threads. Les étudiants construisent un compteur sécurisé pour les threads et comprennent l'empoisonnement de verrou.

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

Passe en revue les exécutants asynchrones, le lancement de tâches et les modèles asynchrones courants comme les délais d'attente et select. Les étudiants exécutent un programme asynchrone complet et gèrent les tâches concurrentes en toute sécurité.

Leçon 4 • Threads et traits Send et Sync

Crée des fils d'exécution du système d'exploitation avec std::thread et explique comment Send et Sync imposent la sécurité des fils d'exécution. Les étudiants comprennent pourquoi Rust empêche les courses aux données au niveau des types.