Formation Rust

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

Enseigne if/else, les boucles et la correspondance par motifs. Permet aux étudiants de diriger l'exécution d'un programme par le biais de branchements et d'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 modèles d'organisation du code utilisés tout au long du cours.

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

Présente les variables, les types scalaires et les types composés. Développe 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 à tous les exercices pratiques.

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

Présente 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 du propriétaire unique et les déplacements de valeur. Aborde 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 inférer automatiquement.

Leçon 4 • Types de tranches

Couvre les tranches de chaîne et les tranches de tableau en tant que vues de référence. Relie les concepts d'emprunt aux modèles pratiques d'accès aux données.

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

Ajoute un comportement aux structures via des blocs impl et des constructeurs. Fait le pont entre la modélisation des 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, les tuples et les unités avec accès aux champs. Fournit l'outil principal pour regrouper des données connexes tout au long du cours.

Leçon 3 • Correspondance par motifs avancée

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

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

Présente 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

Examine Display, Debug, From, Into, Iterator et Clone. L'intégration de ces traits rend les types personnalisés interopérables avec l'ensemble de l'écosystème.

Leçon 2 • Bornes de traits et clauses Where

Contraint les génériques avec des bornes de traits 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

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

Leçon 4 • Distribution dynamique avec les objets de trait

Contraste 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 la propagation concise des erreurs dans les fonctions. Réduit considérablement le code standard dans les fonctions qui appellent plusieurs opérations faillibles.

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

Covers defining error enums, implementing std::error::Error, and conversions. Enables libraries to expose meaningful, structured error information.

Leçon 3 • Gestion des erreurs dans les applications

Présente 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 orientés utilisateur.

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

Explique panic!, assert! et le déroulement de la pile. Établit quand un plantage est approprié par rapport au moment où les erreurs doivent être propagées.

Leçon 1 • Itérateurs personnalisés

Guide les étudiants dans l'implémentation d'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 un comportement en tant que valeur à des itérateurs et des 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 de base. Fournit les structures de données utilisées dans la majorité des programmes Rust réels.

Leçon 4 • Consommation d'itérateurs et collect

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

Leçon 1 • Passage de messages avec les canaux

Enseigne les canaux mpsc pour la communication entre fils d'exécution. Démontre le modèle de concurrence par passage de messages comme alternative à l'état partagé.

Leçon 2 • Essentiels de l'environnement d'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 créer des applications réseau réelles avec l'environnement d'exécution asynchrone dominant.

Leçon 3 • Primitives de synchronisation

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

Leçon 4 • Fondamentaux d'Async/Await

Présente 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 non sécurisés

Explique les cinq superpouvoirs non sécurisés et comment les encapsuler. Les étudiants apprennent à minimiser la surface non sécurisée et à documenter les invariants de sécurité.

Leçon 2 • Interface de fonction étrangère

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

Présente *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 de la mémoire

Présente le trait GlobalAlloc, jemalloc et l'allocation par arènes. Permet un contrôle mémoire fin pour les applications critiques en termes de rendement.