Cours de programmation Rust

Leçon 1 • Syntaxe Rust et types de base

Couvre les variables, les types scalaires et les expressions de base. Fournit le vocabulaire syntaxique nécessaire pour lire et écrire tout programme Rust.

Leçon 2 • Installation et configuration de Rust

Mettez en place rustup, cargo et un éditeur de code pour le développement Rust. Établit les fondations de la chaîne d'outils dont dépend chaque chapitre suivant.

Leçon 3 • Utilisation de Cargo et des crates

Explore les commandes Cargo, la structure de projet et l'ajout de crates externes. Relie les connaissances syntaxiques aux workflows de projet réels utilisés tout au long du cours.

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

Enseigne les constructions if, loop, while et for en Rust. Permet aux étudiants d'écrire des programmes avec une logique de branchement et d'itération.

Leçon 1 • 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 et de concevoir des API avec des données empruntées.

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

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

Leçon 3 • Slices et types String

Couvre les références de slices pour les tableaux et les chaînes, et distingue str de String. Relie les concepts de propriété à la gestion pratique des chaînes et des collections.

Leçon 4 • Modèles de propriété en pratique

Applique les règles de propriété et d'emprunt à des scénarios de code réalistes. Consolide la compréhension en résolvant des conflits courants avec le vérificateur d'emprunt.

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

Ajoute du comportement aux structures via les blocs impl et les fonctions associées. Relie la modélisation des données à l'encapsulation de style orienté objet en Rust.

Leçon 2 • Énumérations et variantes

Définit des énumérations avec des variantes contenant des données et introduit Option. Permet de modéliser des valeurs qui peuvent prendre l'une de plusieurs formes distinctes.

Leçon 3 • Filtrage par motif avec match

Utilise les expressions match pour déstructurer les énumérations, les tuples et les structures. Enseigne la gestion exhaustive des motifs, centrale au contrôle de flux idiomatique en Rust.

Leçon 4 • if let et motifs avancés

Introduit le filtrage par motif concis avec if let, while let et les motifs imbriqués. Étend les compétences en matière de motifs à des scénarios quotidiens de condition et de boucle.

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

Explique quand Rust panique, comment déclencher et intercepter les paniques, et quand les utiliser. Définit la frontière entre les scénarios méritant une panique et les erreurs récupérables.

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

Définit des énumérations d'erreur personnalisées et implémente le trait Error. Permet aux bibliothèques et applications d'exposer des informations d'erreur structurées et significatives.

Leçon 3 • Stratégies de gestion des erreurs

Compare les erreurs encapsulées, les types personnalisés et anyhow pour le code d'application vs. le code de bibliothèque. Guide les étudiants dans le choix de la stratégie appropriée pour chaque contexte.

Leçon 4 • L'opérateur ? et la propagation des erreurs

Utilise l'opérateur ? pour propager les erreurs vers le haut de la pile d'appels de manière concise. Réduit le code répétitif et rend le code de gestion des erreurs lisible et idiomatique.

Leçon 1 • Itérateurs consommateurs

Utilise collect, fold, sum et d'autres consommateurs pour produire des résultats à partir d'itérateurs. Complète le pipeline d'itérateurs de la source à la transformation et à la sortie.

Leçon 2 • Trait Iterator et adaptateurs

Explore le trait Iterator, l'évaluation paresseuse et les méthodes d'adaptation. Enseigne la transformation de données de style fonctionnel, centrale au Rust idiomatique.

Leçon 3 • Itérateurs personnalisés

Implémente le trait Iterator sur des types personnalisés pour produire des séquences. Approfondit la compréhension du fonctionnement interne du mécanisme d'itérateur de Rust.

Leçon 4 • Fermetures et capture de l'environnement

Définit les fermetures, leurs modes de capture et les contraintes de trait Fn. Permet de passer un comportement comme valeur, ce que nécessitent les itérateurs et les fonctions d'ordre supérieur.

Leçon 1 • Définition et implémentation de traits

Crée des traits avec des méthodes obligatoires et par défaut, et les implémente sur des types. Établit le mécanisme de comportement partagé sur lequel reposent les génériques et le polymorphisme.

Leçon 2 • Techniques avancées sur les traits

Couvre les types associés, la surcharge d'opérateurs et le motif Newtype. Étend les connaissances sur les traits à des scénarios de conception d'API sophistiqués.

Leçon 3 • Objets trait et dispatch dynamique

Utilise les pointeurs dyn Trait pour le polymorphisme à l'exécution et explique les coûts des tables virtuelles. Enseigne quand le dispatch dynamique est approprié par rapport au dispatch statique.

Leçon 4 • Bornes de trait et clauses where

Contraint les types génériques avec des bornes de trait et des clauses where. Permet au code générique d'appeler des méthodes de trait tout en gardant les signatures lisibles.

Leçon 1 • Fondamentaux d'Async/Await

Introduit les futures, les fonctions async et le mot-clé await avec un environnement d'exécution. Prépare les étudiants pour l'E/S non bloquante et les modèles d'application à haute concurrence.

Leçon 2 • Traits Send et Sync

Explique les traits marqueurs Send et Sync et leur rôle dans la sécurité des threads. Permet aux étudiants de raisonner sur les types qui peuvent traverser les frontières des threads.

Leçon 3 • Threads et état partagé

Crée des threads du système d'exploitation, partage des données avec Arc et Mutex, et évite les courses aux données. Montre comment les règles de propriété imposent la sécurité des threads à la compilation.

Leçon 4 • Modèles asynchrones et pièges

Couvre les futures concurrentes, la création de tâches et les erreurs asynchrones courantes. Équipe les étudiants pour construire des programmes asynchrones corrects et efficaces dans des contextes de production.

Leçon 1 • Disposition mémoire et pointeurs bruts

Examine comment Rust dispose les données en mémoire et introduit la syntaxe des pointeurs bruts. Fournit la base de bas niveau requise pour les opérations unsafe.

Leçon 2 • Environnements embarqués et sans-std

Configure Rust pour les cibles no_std et utilise les crates core et alloc. Étend les compétences Rust aux microcontrôleurs et aux environnements sans système d'exploitation.

Leçon 3 • Allocateurs personnalisés et gestion de la mémoire

Implémente le trait Allocator et explore l'allocation par arène et par pool. Répond aux scénarios critiques en termes de performances où l'allocation par défaut est insuffisante.

Leçon 4 • Interface de fonctions étrangères

Appelle des fonctions C depuis Rust et expose des fonctions Rust au C en utilisant extern. Permet l'intégration avec des bibliothèques natives existantes et des API système.