Formation Rust

Leçon 1 • Fondamentaux du flux de contrôle

Enseigne les structures if/else, les boucles et le filtrage par motif. Permet aux étudiants de diriger l'exécution du programme via des branchements et des itérations.

Leçon 2 • Fonctions et modules

Définit les signatures de fonctions, les types de retour et la visibilité des modules. Établit les motifs d'organisation du code utilisés tout au long du cours.

Leçon 3 • Syntaxe de base et types de données

Introduit les variables, les types scalaires et les types composés. Construit le vocabulaire nécessaire pour exprimer la logique dans chaque chapitre ultérieur.

Leçon 4 • Cargo et structure du projet

Explore les commandes Cargo, Cargo.toml et la disposition de l'espace de travail. Les étudiants acquièrent les compétences en gestion de projet nécessaires pour tous les exercices pratiques.

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

Introduit les références partagées et mutables avec les règles d'emprunt. Les étudiants apprennent à passer des données sans transférer la propriété.

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

Explique l'invariant de propriétaire unique et les déplacements de valeur. Concerne directement les erreurs de compilation les plus courantes chez les débutants en Rust.

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

Enseigne la syntaxe explicite de durée de vie pour les fonctions et les structures. Permet aux étudiants de résoudre les erreurs de durée de vie que le compilateur ne peut pas déduire automatiquement.

Leçon 4 • Types tranche

Couvre les tranches de chaînes et les tranches de tableaux en tant que vues de référence. Relie les concepts d'emprunt à des motifs d'accès aux données pratiques.

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

Ajoute un comportement aux structures via les blocs impl et les constructeurs. Fait le pont entre la modélisation de données et l'encapsulation de style orienté objet en Rust.

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

Couvre les structures nommées, tuples et unitaires avec accès aux champs. Fournit l'outil principal pour regrouper des données connexes tout au long du cours.

Leçon 3 • Filtrage par motif avancé

Étend match à la déstructuration, aux gardes et aux liaisons. Permet un traitement concis et exhaustif de formes de données complexes.

Leçon 4 • Énumérations et type Option

Introduit les énumérations avec variantes de données et le type Option<T>. Élimine les erreurs de pointeur nul en encodant l'absence de manière explicite dans le système de types.

Leçon 1 • Traits de la bibliothèque standard

Passe en revue Display, Debug, From, Into, Iterator et Clone. L'intégration de ces traits permet aux types personnalisés d'interopérer avec l'ensemble de l'écosystème.

Leçon 2 • Bornes de trait et clauses Where

Contraint les génériques avec des bornes de trait et la syntaxe where. Permet au compilateur de vérifier que les types génériques prennent en charge les opérations requises.

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

Introduit les paramètres de type pour les fonctions, les structures et les énumérations. Permet d'écrire des algorithmes qui fonctionnent sur tout type compatible.

Leçon 4 • Distribution dynamique avec les objets trait

Compare la distribution statique avec dyn Trait pour le polymorphisme à l'exécution. Les étudiants choisissent la stratégie de distribution adaptée à chaque scénario de conception.

Leçon 1 • L'opérateur ? et la propagation

Enseigne l'opérateur ? pour une propagation concise des erreurs dans les fonctions. Réduit considérablement le code passe-partout dans les fonctions qui appellent plusieurs opérations sujettes aux erreurs.

Leçon 2 • Types d'erreur personnalisés

Couvre la définition d'enums d'erreur, l'implémentation de std::error::Error et les conversions. Permet aux bibliothèques d'exposer des informations d'erreur structurées et significatives.

Leçon 3 • Gestion d'erreurs dans les applications

Introduit anyhow pour l'agrégation d'erreurs au niveau application et le contexte. Fait le pont entre les erreurs typées de type bibliothèque et les messages de diagnostic destinés à l'utilisateur.

Leçon 4 • Panique et erreurs irrécupérables

Explique panic!, assert! et le déroulement de la pile. Établit quand il est approprié de faire planter le programme versus quand les erreurs doivent être propagées.

Leçon 1 • Itérateurs personnalisés

Guide les étudiants dans l'implémentation de Iterator sur des structures personnalisées. Approfondit la compréhension du système de traits et permet une itération spécifique au domaine.

Leçon 2 • Fermetures et capture

Explique la syntaxe des fermetures, les modes de capture et les familles de traits Fn. Permet de passer des comportements en tant que valeurs aux itérateurs et aux fonctions d'ordre supérieur.

Leçon 3 • Vec, HashMap et HashSet

Couvre la création, l'insertion, la recherche et la suppression pour les collections principales. Fournit les structures de données utilisées dans la majorité des programmes Rust réels.

Leçon 4 • Itérateurs consommateurs et collect

Couvre les consommateurs fold, sum, count, collect et partition. Convertit les pipelines paresseux en résultats concrets et en collections.

Leçon 1 • Passage de messages avec les canaux

Enseigne les canaux mpsc pour la communication inter-threads. Démontre le modèle de concurrence par passage de messages comme alternative à l'état partagé.

Leçon 2 • Essentiels de l'exécution Tokio

Couvre la configuration de l'exécuteur Tokio, les tâches asynchrones et les primitives d'E/S asynchrones. Permet aux étudiants de construire des applications réseau réelles avec l'environnement d'exécution asynchrone dominant.

Leçon 3 • Primitives de synchronisation

Passe en revue Mutex asynchrone, RwLock, Semaphore et Notify de Tokio. Équipe les étudiants pour coordonner des tâches concurrentes sans courses aux données.

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

Introduit le trait Future, async fn et la syntaxe .await. Fournit le modèle conceptuel pour les E/S non bloquantes dans les applications Rust.

Leçon 1 • Blocs et fonctions unsafe

Explique les cinq super-pouvoirs unsafe et comment les encapsuler. Les étudiants apprennent à minimiser la surface unsafe et à documenter les invariants de sécurité.

Leçon 2 • Interface de fonctions étrangères (FFI)

Couvre les blocs extern, l'ABI C et l'appel de bibliothèques C depuis Rust. Permet l'intégration avec des bases de code natives existantes et des bibliothèques système.

Leçon 3 • Pointeurs bruts et disposition mémoire

Introduit *const T et *mut T, l'arithmétique des pointeurs et l'alignement mémoire. Fournit la base pour la FFI et la gestion manuelle de la mémoire.

Leçon 4 • Allocateurs personnalisés et gestion mémoire

Introduit le trait GlobalAlloc, jemalloc et l'allocation par arène (arena). Permet un contrôle mémoire fin pour les applications critiques en termes de performances.