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. Cela permet de se familiariser avec la syntaxe avant l'introduction de concepts plus avancés.

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

Explique l'installation via 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

Présente les objectifs de conception de Rust : sécurité mémoire sans ramasse-miettes, abstractions sans coût, et performances au niveau système. Donne 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 et mutabilité des variables

Explique les liaisons let, l'immuabilité par défaut et le mot-clé mut. L'immuabilité est une fonctionnalité de sécurité fondamentale qui revient dans les sujets sur la possession 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 instructions et expressions utilisée 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 clonage explicite pour les types sur le tas. Évite toute confusion lorsque des 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 explicites de durée de vie 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 en tant que vues empruntées

Couvre les slices de chaînes et les slices de tableaux en tant que références vers des données contiguës. Les slices apparaissent dans presque toutes les API Rust et signatures de fonctions du monde réel.

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 répétitif lorsqu'un seul variant doit être traité.

Leçon 2 • Énumérations et variants

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

Leçon 3 • Définition et utilisation de structures

Couvre les structures à champs nommés, les structures tuples et les structures unitaires avec la syntaxe d'instanciation. Les structures sont l'outil principal pour regrouper des données apparentées 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 de caractères 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 la panique de Result, explique unwrap et expect, et couvre les cas où 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 avec la possession. Les vecteurs sont la collection allouée sur le tas la plus courante dans les programmes Rust.

Leçon 4 • Gestion des erreurs avec Result

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

Leçon 1 • Définition et implémentation de 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 répartition dynamique

Explique dyn Trait, les pointeurs larges et le compromis entre la répartition 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 trait. 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 écrire du Rust idiomatique dans tous les domaines.

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

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 • Pliage et agrégation de 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 le couplage fort et expose des API publiques propres.

Leçon 2 • Tests 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 • Utilisation de paquets logiciels 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 • Paquets logiciels et le manifeste Cargo

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