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 n'importe quel programme Rust.

Leçon 2 • Installation et configuration de Rust

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

Leçon 3 • Utiliser Cargo et les crates

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

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

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 • Types tranche (slice) et chaîne de caractères

Couvre les références de tranche pour les tableaux et les chaînes, et distingue str de String. Fait le pont entre les concepts de propriété et 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 les conflits courants avec le vérificateur d'emprunt.

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

Ajoute un comportement aux structures via les blocs impl et les fonctions associées. Relie la modélisation des données à l'encapsulation de style orientée 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 pouvant 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 flux de contrôle idiomatique en Rust.

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

Introduit le filtrage concis par motif 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 attraper les paniques, et quand les utiliser. Définit la frontière entre les scénarios d'erreur justifiant une panique et ceux 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 aux applications d'exposer des informations d'erreur structurées et significatives.

Leçon 3 • Stratégies de gestion d'erreur

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

Leçon 4 • L'opérateur ? et la propagation d'erreur

Utilise l'opérateur ? pour propager concisément les erreurs vers le haut de la pile d'appels. Réduit le code boilerplate et rend le code de gestion d'erreur 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. Achève le pipeline d'itérateur de la source, via la transformation, jusqu'à la sortie.

Leçon 2 • Trait Iterator et adaptateurs

Explore le trait Iterator, l'évaluation paresseuse et les méthodes adaptatrices. 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ération de Rust.

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

Définit les fermetures, leurs modes de capture et les bornes du trait Fn. Permet de passer un comportement comme valeur, ce qui est requis par les itérateurs et les fonctions d'ordre supérieur.

Leçon 1 • Définir et implémenter des 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 de traits

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

Leçon 3 • Objets trait et dispatch dynamique

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

Leçon 4 • Bornes de traits et clauses where

Contraint les types génériques avec des bornes de traits 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 moteur d'exécution. Prépare les étudiants aux motifs d'application à haute concurrence et aux E/S non bloquantes.

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 de thread.

Leçon 3 • Threads et état partagé

Lance des threads OS, partage des données avec Arc et Mutex, et évite les accès concurrents. Démontre comment les règles de propriété imposent la sécurité des threads à la compilation.

Leçon 4 • Motifs asynchrones et pièges

Couvre les futures concurrentes, le lancement 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 les bases de bas niveau nécessaires aux opérations unsafe.

Leçon 2 • Environnements embarqués et no_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 (FFI)

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