Formation aux bases de Rust

Leçon 1 • Écrire votre premier programme Rust

Guide les étudiants à travers un programme Rust minimal, en expliquant les points d'entrée, les macros et la compilation. Développe la familiarité avec la syntaxe avant d'introduire des concepts plus approfondis.

Leçon 2 • Installer la chaîne d'outils Rust

Parcourt l'installation de rustup, la gestion des versions de la chaîne d'outils et la vérification de la configuration. Fournit la base pour tous les exercices pratiques du cours.

Leçon 3 • Pourquoi Rust existe

Couvre les objectifs de conception de Rust : sécurité mémoire sans ramasse-miettes, abstractions à coût zéro et performance système. Établit le contexte pour chaque concept introduit plus tard.

Leçon 1 • Constructions de flux de contrôle

Enseigne les constructions if/else, loop, while et for, y compris leur nature basée sur les expressions. Prépare les étudiants au filtrage par motif introduit dans les chapitres suivants.

Leçon 2 • Liaison de variables et mutabilité

Explique les liaisons let, l'immuabilité par défaut et le mot-clé mut. L'immuabilité est une fonctionnalité de sécurité centrale qui réapparaît dans les sujets sur la propriété et la concurrence.

Leçon 3 • Fonctions et expressions

Explique les signatures de fonctions, les types de retour et le modèle d'évaluation orienté expression de Rust. Établit la distinction entre les instructions et les expressions utilisées dans tout le langage.

Leçon 4 • Types scalaires et composés

Couvre les entiers, les flottants, les booléens, les caractères, les tuples et les tableaux. La compréhension de ces types est un prérequis pour travailler avec les structures, les énumérations et les collections.

Leçon 1 • Clonage et copie

Distingue le trait Copy pour les types sur la pile du clone explicite pour les types sur le tas. Empêche la confusion lorsque les valeurs semblent être dupliquées de manière inattendue.

Leçon 2 • Bases des annotations de durée de vie

Explique quand le compilateur nécessite des annotations de durée de vie explicites et comment les écrire. Construit la compréhension minimale nécessaire avant d'introduire les génériques avancés.

Leçon 3 • Les slices comme vues empruntées

Couvre les slices de chaînes et les slices de tableaux comme références à des données contiguës. Les slices apparaissent dans presque toutes les API Rust réelles et les signatures de fonctions.

Leçon 4 • Références et emprunt

Introduit les références partagées et mutables, en appliquant la règle d'aliasing XOR mutabilité. Les étudiants écrivent des fonctions qui accèdent aux données sans en prendre possession.

Leçon 1 • Motifs concis : if let et while let

Introduit if let et while let comme alternatives ergonomiques aux expressions match complètes. Réduit le code standard lorsqu'un seul variant nécessite une gestion.

Leçon 2 • Énumérations et variants

Définit les énumérations avec des variants portant des données et explique leur disposition en mémoire. Les énumérations permettent une modélisation exhaustive des états, remplaçant les indicateurs entiers sujets aux erreurs.

Leçon 3 • Définir et utiliser des structures

Couvre les structures à champs nommés, les structures tuple et les structures unité avec la syntaxe d'instanciation. Les structures sont l'outil principal pour regrouper des données connexes dans les programmes Rust.

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

Enseigne les blocs impl, les variantes du paramètre self et les fonctions constructrices associées. Encapsule le comportement aux côtés des données avant l'introduction des traits.

Leçon 1 • Chaînes et slices de chaînes

Explique le type String, l'encodage UTF-8, la concaténation et les règles de découpage. Clarifie la confusion courante entre String et &str dans les signatures de fonctions.

Leçon 2 • Paniques et erreurs irrécupérables

Distingue panic de Result, explique unwrap et expect, et couvre quand paniquer est approprié. Empêche l'utilisation abusive des paniques dans le code de bibliothèque et de production.

Leçon 3 • Vecteurs

Couvre la création de Vec, l'ajout, l'indexation, l'itération et les interactions de propriété. Les vecteurs sont la collection allouée sur le tas la plus courante dans les programmes Rust.

Leçon 4 • Gérer les erreurs avec Result

Couvre l'opérateur ?, la gestion des erreurs basée sur match et la conversion entre les types d'erreur. Établit l'approche idiomatique de Rust pour les erreurs récupérables.

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

Explique les définitions de traits, les implémentations de méthodes par défaut et l'implémentation de traits sur des types personnalisés. Les traits sont le principal mécanisme d'abstraction de Rust pour le comportement partagé.

Leçon 2 • Objets traits et dispatch dynamique

Explique dyn Trait, les pointeurs larges et le compromis entre le dispatch statique et dynamique. Permet les collections hétérogènes et les architectures de type plugin.

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

Introduit les paramètres de type dans les fonctions et les structures avec des bornes de traits. Permet d'écrire des algorithmes qui opèrent sur n'importe quel type satisfaisant des contraintes spécifiées.

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

Couvre Display, Debug, Clone, PartialEq, PartialOrd et Iterator. La familiarité avec ces traits est nécessaire pour un Rust idiomatique dans tous les domaines.

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

Couvre map, filter, flat_map, take, skip, zip et collect. Les étudiants construisent des pipelines de données lisibles qui se compilent en code machine efficace.

Leçon 2 • Le trait Iterator

Définit le trait Iterator, la méthode next et comment implémenter un itérateur personnalisé. Fournit la base pour comprendre tous les adaptateurs d'itérateur.

Leçon 3 • Plier et agréger des données

Enseigne fold, reduce, sum, product, any, all et find pour agréger la sortie d'un itérateur. Complète la boîte à outils pour remplacer les boucles impératives par des pipelines déclaratifs.

Leçon 4 • Fermetures : syntaxe et captures

Couvre la syntaxe des fermetures, la capture de l'environnement par référence ou par valeur, et le mot-clé move. Les fermetures sont largement utilisées dans les itérateurs, les threads et le code asynchrone.

Leçon 1 • Modules et visibilité

Explique le mot-clé mod, la disposition des modules basée sur les fichiers et les règles de visibilité pub. Une conception de module appropriée empêche un couplage fort et expose des API publiques propres.

Leçon 2 • Tester dans les modules

Couvre les tests unitaires dans les modules #[cfg(test)], les tests d'intégration dans le répertoire tests et les tests de documentation. Intègre une culture de test dès le niveau de la structure du projet.

Leçon 3 • Utiliser des crates externes

Montre comment ajouter des dépendances depuis crates.io, les contraintes de version et la réexportation d'éléments. Permet aux étudiants de tirer parti de l'écosystème Rust dans leurs projets.

Leçon 4 • Crates et le manifeste Cargo

Définit les crates binaires et de bibliothèque, les champs Cargo.toml et la configuration des espaces de travail. Les étudiants comprennent comment les projets Rust sont compilés et liés.