Cours de programmation Rust pour débutants

Leçon 1 • Cargo : le système de construction de Rust

Présente Cargo pour créer des projets, gérer les dépendances et exécuter les constructions. Les étudiants acquièrent les bases du flux de travail utilisées tout au long du cours.

Leçon 2 • Écrire votre premier programme Rust

Parcourt un programme Hello World, expliquant la fonction main, les macros et la sortie de compilation. Relie les bases de la syntaxe à la structure plus large du langage.

Leçon 3 • Installation de Rust et configuration de la chaîne d'outils

Guide l'installation via rustup, la configuration du compilateur et la gestion des versions de la chaîne d'outils. Garantit à chaque étudiant un environnement de développement reproductible et fonctionnel.

Leçon 1 • Types de données scalaires

Couvre les entiers, les nombres à virgule flottante, les booléens et les caractères avec leurs tailles et plages. Fournit les éléments de base primitifs pour toute modélisation de données ultérieure.

Leçon 2 • Types composés : tuples et tableaux

Introduit les types composés de taille fixe, la déstructuration et l'accès par index. Les étudiants apprennent à regrouper des valeurs associées sans allocation de tas.

Leçon 3 • Variables, mutabilité et masquage

Explique les liaisons let, la règle d'immuabilité par défaut, mut et la sémantique de masquage. Établit la discipline de mutabilité explicite, centrale pour un code Rust sûr.

Leçon 1 • Expressions conditionnelles

Couvre if, else if et else en tant qu'expressions qui retournent des valeurs, pas seulement des instructions. Renforce la conception orientée expression de Rust introduite dans les chapitres précédents.

Leçon 2 • Définition et appel de fonctions

Explique les signatures de fonctions, les types de paramètres, les types de retour et les retours implicites. Établit la fonction comme unité principale de réutilisation de code dans Rust.

Leçon 3 • Correspondance de motifs avec match

Introduit la correspondance de motifs exhaustive comme outil de flux de contrôle supérieur aux longues chaînes if-else. Prépare les étudiants à la conception basée sur les énumérations dans les chapitres suivants.

Leçon 4 • Fermetures et fonctions d'ordre supérieur

Couvre la syntaxe des fermetures, la capture de variables depuis l'environnement et le passage de fermetures à des fonctions. Jette les bases de la programmation basée sur les itérateurs introduite plus tard.

Leçon 1 • Règles de possession et sémantique de déplacement

Définit les trois règles de possession et explique comment les valeurs se déplacent entre les portées. C'est le cœur conceptuel qui distingue Rust de tous les autres langages.

Leçon 2 • Tranches en tant que vues empruntées

Explique les tranches de chaîne et les tranches de tableau comme des références à des données contiguës. Relie les concepts d'emprunt à des schémas pratiques d'accès aux données.

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

Introduit les références immuables et mutables, les règles d'alias et la prévention des références pendantes. Les étudiants apprennent à partager des données sans transférer la possession.

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

Enseigne la syntaxe explicite de durée de vie, les règles d'élision de durée de vie et les bornes de durée de vie sur les fonctions et les structures. Permet aux étudiants d'écrire des API qui retournent des références en toute sécurité.

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

Couvre les structures à champs nommés, les structures tuples et les structures unitaires avec instanciation et accès aux champs. Fournit l'outil principal pour regrouper des données connexes dans les programmes Rust.

Leçon 2 • Option et null safety

Couvre l'énumération Option<T> comme remplacement de null par Rust, avec correspondance de motifs et combinateurs. Élimine les erreurs de pointeur null lors de la compilation.

Leçon 3 • Énumérations et données de variante

Introduit les énumérations avec des variantes portant des données, permettant des types de données algébriques. Débloque la modélisation expressive des états, des erreurs et des valeurs optionnelles.

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

Explique les blocs impl, les variantes du paramètre self et les fonctions associées comme les constructeurs. Encapsule le comportement avec les données dans un style orienté objet.

Leçon 1 • Erreurs récupérables avec Result

Introduit Result<T, E>, ses variantes Ok et Err, et la correspondance de base pour la gestion des erreurs. Établit la base pour tous les schémas de gestion d'erreurs dans Rust.

Leçon 2 • Erreurs irrécupérables et paniques

Couvre panic!, unwrap et expect, expliquant quand paniquer est acceptable ou nuisible. Apprend aux étudiants à distinguer les bogues de programmation des échecs d'exécution récupérables.

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

Guide la création d'énumérations d'erreur spécifiques au domaine et l'implémentation du trait Error. Permet un rapport d'erreurs clair et structuré dans le code de bibliothèque et d'application.

Leçon 4 • L'opérateur ? pour la propagation

Explique comment ? dépaquette Ok ou retourne Err prématurément, réduisant le code passe-partout dans les fonctions faillibles. Relie au trait From pour la conversion automatique de type d'erreur.

Leçon 1 • Chaînes : String vs &str

Clarifie la distinction entre String possédé et &str emprunté, couvrant la création, la concaténation et le découpage. Résout la source de confusion la plus courante pour les débutants Rust.

Leçon 2 • Vecteurs et tableaux dynamiques

Couvre la création, la croissance, l'indexation et l'itération de Vec<T> avec des considérations de possession. Fournit la collection allouée sur le tas la plus couramment utilisée dans les programmes Rust.

Leçon 3 • Types et fonctions génériques

Introduit les paramètres de type génériques, la monomorphisation et les bornes de trait sur les génériques. Permet aux étudiants d'écrire des implémentations uniques qui fonctionnent sur de nombreux types concrets.

Leçon 4 • Trait Iterator et adaptateurs

Explique le trait Iterator, l'évaluation paresseuse et les adaptateurs comme map, filter et collect. Permet une transformation de données de style fonctionnel sans surcharge à l'exécution.

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

Couvre 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. Fournit le mécanisme principal de Rust pour le polymorphisme et les interfaces partagées.

Leçon 2 • Crates, paquets et espaces de travail

Explique la distinction entre crate et paquet, la configuration Cargo.toml et les espaces de travail multi-crates. Prépare les étudiants à structurer des projets Rust professionnels et multi-composants.

Leçon 3 • Objets trait et dispatch dynamique

Explique dyn Trait, Box<dyn Trait> et les compromis entre dispatch statique et dynamique. Permet le polymorphisme à l'exécution lorsque les types génériques sont insuffisants.

Leçon 4 • Modules et visibilité

Enseigne les déclarations mod, la visibilité pub, les imports use et l'organisation des modules multi-fichiers. Permet une séparation claire des préoccupations au sein de grandes bases de code.