Version : 1.2.0
Dernière mise à jour : 7 Décembre 2025
Public cible : Débutant absolu → Expert
- ✅ 403 exercices complets avec code de départ et tests
- ✅ Tous les exercices enrichis avec du code fonctionnel
- ✅ Progression structurée : Beginner (100) -> Intermediate (70) -> Advanced (34)
- ✅ Chaque exercice inclut CHALLENGE.md, src/main.rs et Cargo.toml. Amusez Vous!
Bienvenue dans le guide d'apprentissage Rust le plus complet jamais créé, et en francais !
Ce dépôt est conçu pour accompagner n'importe qui même sans expérience de programmation depuis les bases absolues jusqu'à l'expertise avancée en Rust.
Rust est un langage révolutionnaire créé par Mozilla pour résoudre un problème fondamental en programmation système :
- Rapide : compile en code machine ultra-performant (comme C/C++)
- Sûr : empêche les bugs mémoire (use-after-free, double-free) avant la compilation
- Concurrent : gère la parallélisation sans data races
- Idiomatique : encourage les bonnes pratiques par design
Utilisé par : Discord, Cloudflare, Figma, Meta, Amazon, Microsoft, Linux Kernel 6.1+, et bien d'autres.
- ✅ 50 chapitres progressifs (niveau 0 → expert)
- ✅ 403 exercices complets avec code de départ et tests automatisés
- ✅ 6 mini-projets complets et documentés
- ✅ Cheatsheets imprimables (ownership, lifetimes, traits, async)
- ✅ Diagrammes et mindmaps pour concepts complexes
- ✅ Focus sécurité : OPSEC, cryptographie, pentesting
- ✅ Code exécutable : tous les exemples fonctionnent
- Présentation du projet
- Installation rapide
- Parcours d'apprentissage
- Table des matières détaillée
- Objectifs pédagogiques
- Structure du dépôt
- Accès direct aux fichiers
- Mini-projets
- Feuille de route
- Contribution
- Licence
- Support et communauté
Aucune connaissance préalable en programmation n'est requise ! 🎉
Linux / macOS :
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/envWindows : Télécharge et exécute rustup-init.exe
rustc --version
cargo --versiongit clone https://github.com/bluectx/Rust-Complete-Pack.git
cd Rust-Complete-Packcd book/ch01-foundations
cat 01-01-what-is-programming.mdLe guide est structuré en 5 niveaux progressifs :
| Niveau | Chapitres | Durée estimée | Compétences acquises |
|---|---|---|---|
| 🌱 Niveau 0 : Fondations | 1-5 | 1 semaine | Comprendre la programmation, installer Rust, écrire premier programme |
| 🟢 Débutant | 6-11 | 2 semaines | Variables, types, contrôle de flux, fonctions |
| 🟡 Intermédiaire | 12-30 | 4 semaines | Ownership, lifetimes, traits, génériques, closures, modules |
| 🟠 Avancé | 31-40 | 2 semaines | Collections, smart pointers, concurrence, async/await, macros |
| 🔴 Expert | 41-50 | 1 semaine | Unsafe, FFI, WASM, embedded, sécurité, patterns avancés |
Durée totale estimée : 10 semaines à raison de 2-3h par jour.
- 1.1 Ordinateurs et instructions
- 1.2 Qu'est-ce qu'un langage ?
- 1.3 Compilation vs interprétation
- 1.4 Pourquoi Rust ?
- 1.5 Ressources officielles
- 2.1 Installer rustup (Linux, macOS, Windows)
- 2.2 Vérifier l'installation
- 2.3 Éditions Rust (2021, 2024)
- 2.4 Créer premier projet avec cargo
- 2.5 Comprendre Cargo.toml
- 3.1 La fonction main()
- 3.2 Macro println!
- 3.3 Structure d'un fichier source
- 3.4 Commentaires
- 3.5 Exécution et debugging
- 4.1 Variables = boîtes pour stocker données
- 4.2 Immuabilité par défaut (mindset Rust)
- 4.3 Mot-clé
mutpour mutabilité explicite - 4.4 Scope de variable
- 4.5 Shadowing et réassignation
- 5.1 Entiers signés : i8, i16, i32, i64, i128, isize
- 5.2 Entiers non-signés : u8, u16, u32, u64, u128, usize
- 5.3 Débordement et wrap-around
- 5.4 Nombres flottants : f32, f64 et précision
- 5.5 Booléens (bool) et opérateurs logiques
- 5.6 Caractères (char) et Unicode
- 6.1 Tuples : collections hétérogènes
- 6.2 Déballage de tuples (destructuring)
- 6.3 Arrays : collections homogènes de taille fixe
- 6.4 Slices : vues sur arrays
- 6.5 Indexation et bounds checking
- 7.1 String : chaîne possédée, mutables, heap-allocated
- 7.2 &str : slice de string, immuable, littéraux
- 7.3 Pourquoi deux types ?
- 7.4 Conversion entre String et &str
- 7.5 Manipulation : chars, bytes, graphèmes
- 8.1 Constantes : valeurs inchangeables à compile-time
- 8.2 Variables : état mutable à runtime
- 8.3 Shadowing : relier un nom à nouvelle valeur
- 9.1 if/else if/else comme expressions
- 9.2 Opérateurs de comparaison
- 9.3 Opérateurs logiques (&&, ||, !)
- 9.4 Expressions ternaires implicites
- 9.5 Blocs et valeurs de retour
- 10.1 Boucle infinie :
loop { } - 10.2 Boucle conditionnelle :
while - 10.3 Boucle sur collection :
for - 10.4 Étiquettes de boucle et break
- 10.5 Continue et contrôle de flux
- 11.1 Définition et paramètres
- 11.2 Types de paramètres
- 11.3 Valeurs de retour explicites
- 11.4 Expressions implicites (dernière ligne)
- 11.5 Scope et visibilité (pub)
- 12.1 Règle 1 : Chaque valeur a UN propriétaire
- 12.2 Règle 2 : Transfert (move) de propriété
- 12.3 Règle 3 : Suppression quand propriétaire drop
- 12.4 Visualiser ownership sur stack/heap
- 12.5 Move semantics vs copy semantics
- 13.1 Quels types implémentent Copy ?
- 13.2 Copy = duplication automatique
- 13.3 Différence entre Copy et Move
- 13.4 Clone trait pour copie explicite
- 14.1 Emprunter = lecture sans transfert
- 14.2 Syntaxe &variable
- 14.3 Immuabilité garantie
- 14.4 Multiples emprunts simultanés (OK)
- 14.5 Emprunts et scope
- 15.1 Emprunt mutable = modification sans transfert
- 15.2 Syntaxe &mut variable
- 15.3 Règle XOR : UNE SEULE référence mutable
- 15.4 Pas de data races
- 15.5 Emprunt mutable vs immuable
- 16.1 Le compilateur vérifie propriété + emprunts
- 16.2 Erreur : cannot borrow as mutable
- 16.3 Erreur : cannot move (borrowed value)
- 16.4 Dépannage système
- 16.5 Visualisation timeline emprunt
- 17.1 Qu'est-ce qu'une lifetime ?
- 17.2 Annotation explicite : 'a, 'b, 'static
- 17.3 Lifetimes sur fonctions
- 17.4 Lifetimes sur structs
- 17.5 Élision implicite
- 17.6 Dangling references prevention
- 18.1 Patterns de possession
- 18.2 Retourner ownership
- 18.3 Tuple destructuring propriété
- 18.4 Scope imbriqué
- 19.1 Définition de struct
- 19.2 Instantiation
- 19.3 Accès aux champs (field access)
- 19.4 Mutabilité au niveau struct
- 19.5 Struct patterns
- 20.1 Blocs impl
- 20.2 Méthodes : self, &self, &mut self
- 20.3 Associated functions
- 20.4 Multiples blocs impl
- 20.5 Dérivation automatique (derive)
- 21.1 Variantes enum
- 21.2 Enum avec données associées
- 21.3 Option<T> : absence vs présence
- 21.4 Result<T, E> : succès vs erreur
- 21.5 Enum methods
- 22.1 Match expressions exhaustives
- 22.2 Patterns immuables
- 22.3 Destructuring dans patterns
- 22.4 Wildcard (_) et catch-all
- 22.5 Match guards (if conditions)
- 23.1 Absence de valeur sans null
- 23.2 Déballage : unwrap, expect
- 23.3 Chainable methods : map, and_then
- 23.4 if let et while let
- 23.5 Patterns sur Option
- 24.1 Succès (Ok) vs erreur (Err)
- 24.2 Propagation d'erreurs (? operator)
- 24.3 Chainable methods : map_err, or_else
- 24.4 Custom error types
- 24.5 Converting entre error types
- 25.1 Définition de trait
- 25.2 Implémentation de trait
- 25.3 Trait bounds sur generics
- 25.4 Multiple trait bounds
- 25.5 Traits standards : Display, Debug, Clone, Copy, Default
- 26.1 Type parameters T
- 26.2 Génériques sur fonctions
- 26.3 Génériques sur structs
- 26.4 Génériques sur enums
- 26.5 Monomorphization
- 27.1 Single trait bound : T: Display
- 27.2 Multiple bounds : T: Display + Clone
- 27.3 Where clauses
- 27.4 Associated types
- 27.5 Higher-ranked trait bounds (HRTB)
- 28.1 Syntaxe : |x| x + 1
- 28.2 Type inference
- 28.3 Fn, FnMut, FnOnce traits
- 28.4 Capture d'environnement
- 28.5 Move keyword et ownership
- 29.1 Iterator trait : next() method
- 29.2 Adaptateurs : map, filter, fold
- 29.3 Consommateurs : collect, sum, count
- 29.4 Chaîner des adaptateurs
- 29.5 Lazy evaluation
- 30.1 Système de modules Rust
- 30.2 Chemin de module (path)
- 30.3 Visibilité (pub, pub(crate), pub(super))
- 30.4 Use statements et imports
- 30.5 Crate et package Cargo
- 31.1 Vec<T> : vecteurs dynamiques
- 31.2 VecDeque, LinkedList
- 31.3 HashMap : clé-valeur
- 31.4 BTreeMap : ordre trié
- 31.5 HashSet et BTreeSet
- 31.6 Capacité et réallocation
- 32.1 Panics vs Recoverable errors
- 32.2 Result<T, E> comme pattern
- 32.3 Custom error types avec traits
- 32.4 Chaîner Results
- 32.5 Best practices OPSEC
- 33.1 Box : allocation sur heap
- 33.2 Deref trait et coercion
- 33.3 Cas d'usage
- 33.4 Drop trait et RAII
- 33.5 Recursive types avec Box
- 34.1 Rc : reference counting
- 34.2 Multiple ownership
- 34.3 RefCell : interior mutability
- 34.4 Weak<T> : prévenir cycles
- 34.5 Debugging reference cycles
- 35.1 Arc : atomic reference counting (thread-safe)
- 35.2 Mutex : synchronisation
- 35.3 RwLock : reader-writer lock
- 35.4 Deadlock prevention
- 35.5 Condvar : condition variables
- 36.1 Spawn de threads
- 36.2 Join et attendre résultat
- 36.3 Move closures et ownership
- 36.4 Send et Sync traits
- 36.5 Data races prevention
- 37.1 Message passing : mpsc channels
- 37.2 Send et receive
- 37.3 Multiple producers
- 37.4 Synchronous vs asynchronous
- 37.5 Blocking channels
- 38.1 Async functions
- 38.2 Await operator
- 38.3 Futures trait
- 38.4 Async blocks
- 38.5 Runtime requirements
- 39.1 Tokio : async runtime populaire
- 39.2 Tokio::spawn pour tasks
- 39.3 TCP sockets
- 39.4 HTTP client/server basics
- 39.5 Timeouts et cancellation
- 40.1 Macro rules! syntax
- 40.2 Patterns de macro
- 40.3 Repetition ($(...)*,)
- 40.4 Debugging macros
- 40.5 Common macros (println!, vec!, etc.)
- 41.1 Derive macros
- 41.2 Attribute macros
- 41.3 Function-like macros
- 41.4 TokenStream manipulation
- 41.5 Debugging procedural macros
- 42.1 Quand utiliser unsafe
- 42.2 Dereferencing raw pointers (*const, *mut)
- 42.3 Unsafe functions
- 42.4 Mutable statics
- 42.5 Unions et packed structs
- 43.1 Binding C libraries
- 43.2 Type correspondences (C → Rust)
- 43.3 extern "C" functions
- 43.4 Callbacks depuis C
- 43.5 Memory safety concerns
- 44.1 Stack vs Heap
- 44.2 Alignment et padding
- 44.3 Size, size_of_val
- 44.4 Zero-copy abstractions
- 44.5 Escape analysis
- 45.1 Compilation phases
- 45.2 MIR (Mid-level IR)
- 45.3 LLVM backend
- 45.4 Debug vs Release
- 45.5 Link-time optimization (LTO)
- 46.1 Unit tests (#[test])
- 46.2 Integration tests
- 46.3 Doc tests
- 46.4 Criterion benchmarking
- 46.5 Fuzzing et property testing
- 47.1 cargo-expand (voir MIR)
- 47.2 cargo-clippy (linting)
- 47.3 cargo-audit (vulnerabilités)
- 47.4 cargo-tree (dépendances)
- 47.5 Build scripts (build.rs)
- 48.1 Compilation vers WebAssembly
- 48.2 wasm-bindgen
- 48.3 Performance WASM
- 48.4 no_std programming
- 48.5 Embedded Rust basics
- 49.1 Buffer overflow prevention
- 49.2 Integer overflow/underflow
- 49.3 Use-after-free prevention
- 49.4 Constant-time comparisons
- 49.5 Secret management (zeroize)
- 50.1 Builder pattern
- 50.2 Type state pattern
- 50.3 RAII (Resource Acquisition Is Initialization)
- 50.4 Newtype pattern
- 50.5 Composing abstractions
Après ces chapitres, vous comprendrez :
- ✅ Qu'un langage de programmation = grammaire pour parler à un ordinateur
- ✅ Comment installer Rust et créer un premier projet
- ✅ Anatomie d'un programme simple
- ✅ Comment exécuter et déboguer du code
Vocabulaire clé :
- Compilateur, bytecode, machine code, assembly
- Source code, executable, binary
- REPL vs compiled languages
Après ces chapitres, vous pourrez :
- ✅ Déclarer variables immuables et mutables
- ✅ Utiliser tous les types primitifs correctement
- ✅ Comprendre collections (tuples, arrays, slices)
- ✅ Manipuler chaînes (String vs &str)
Vocabulaire clé :
- Variable, assignation, mutation, shadowing
- Type inference, casting, type coercion
- Stack frame, scope, lifetime
- Owned vs borrowed
Après ces chapitres, vous pourrez :
- ✅ Brancher le code avec conditions
- ✅ Boucler efficacement avec for/while/loop
- ✅ Décomposer code en fonctions réutilisables
- ✅ Passer arguments et retourner valeurs
Vocabulaire clé :
- Expression vs statement
- Guard, match, exhaustiveness
- Function signature, return type
Après ces chapitres, vous comprendrez :
- ✅ Pourquoi Rust est sûr sans garbage collector
- ✅ Comment le transfert (move) de propriété fonctionne
- ✅ Emprunter sans transférer (borrowing)
- ✅ Éviter dangling references avec lifetimes
- ✅ Design d'API safe et efficace
Vocabulaire clé :
- Ownership, move, copy, clone
- Borrow, reference, mutable borrow
- Lifetime, scope, drop
- Borrow checker, data race
Compétences acquises :
- Corriger TOUS les erreurs "cannot borrow"
- Écrire du code safe sans null pointers
- Profiler et optimiser allocations
Après ces chapitres, vous pourrez :
- ✅ Modéliser un domaine avec structs/enums
- ✅ Implémenter méthodes et behaviors
- ✅ Utiliser traits pour abstraction
- ✅ Écrire du code réutilisable avec generics
Vocabulaire clé :
- Struct, field, method
- Enum, variant, pattern
- Trait, implementation, bound
- Generic type parameter
Après ces chapitres, vous pourrez :
- ✅ Utiliser closures et itérateurs
- ✅ Chaîner transformations fonctionnelles
- ✅ Organiser code en modules/crates
- ✅ Comprendre lazy evaluation
Vocabulaire clé :
- Closure, capture, move
- Iterator, adapter, consumer
- Module, crate, path
- Visibility, pub
Après ces chapitres, vous pourrez :
- ✅ Écrire du code concurrent sans data races
- ✅ Utiliser threads et message passing
- ✅ Écrire du code async/await avec tokio
- ✅ Implémenter serveurs et clients réseau
Vocabulaire clé :
- Thread, task, future
- Channel, mutex, rwlock
- Async, await, runtime
- Send, sync
Après ces chapitres, vous serez :
- ✅ Capable d'utiliser unsafe code consciemment
- ✅ Capable d'interfacer C libraries (FFI)
- ✅ Capable de compiler vers WASM
- ✅ Capable d'écrire du code embedded
- ✅ Expert en sécurité & OPSEC Rust
Vocabulaire clé :
- Unsafe, raw pointer, transmute
- FFI, extern "C", ABI
- WASM, no_std, bare-metal
- Fuzzing, sanitizer, MIRI
Rust-Complete-Pack/
│
├── README.md # Ce fichier
├── SUMMARY.md # Vue d'ensemble de la structure
├── Cargo.toml # Workspace root
├── .cursorrules # Règles de génération
│
├── book/ # Contenu pédagogique principal
│ ├── SUMMARY.md
│ ├── ch01-foundations/ # Chapitre 1
│ │ ├── 01-01-what-is-programming.md
│ │ ├── 01-02-what-is-rust.md
│ │ ├── 01-03-installation.md
│ │ ├── 01-04-hello-world.md
│ │ └── 01-05-anatomy.md
│ ├── ch02-primitives/ # Chapitre 2
│ ├── ch03-composites/ # Chapitre 3
│ ├── ... # Chapitres 4-49
│ └── ch50-patterns/ # Chapitre 50
│
├── exercises/ # Exercices pratiques
│ ├── ch01-exercises/
│ │ ├── ex01-hello-world/
│ │ │ ├── Cargo.toml
│ │ │ ├── src/main.rs
│ │ │ ├── tests/solution_tests.rs
│ │ │ ├── CHALLENGE.md
│ │ │ └── SOLUTION.md
│ │ ├── ex02-variables/
│ │ └── ex03-types/
│ ├── ch02-exercises/
│ ├── ...
│ └── EXERCISE_INDEX.md
│
├── projects/ # Mini-projets complets
│ ├── p01-hello-world/
│ │ ├── Cargo.toml
│ │ ├── src/main.rs
│ │ ├── tests/integration_tests.rs
│ │ └── README.md
│ ├── p02-cli-calculator/
│ ├── p03-mini-http-server/
│ ├── p04-data-pipeline/
│ ├── p05-terminal-game/
│ ├── p06-web-service/
│ └── PROJECTS_INDEX.md
│
├── cheatsheets/ # Aide-mémoire imprimables
│ ├── ownership-lifetimes.md
│ ├── pattern-matching.md
│ ├── traits-bounds.md
│ ├── closures.md
│ ├── async-await.md
│ └── security-checklist.md
│
├── assets/ # Ressources visuelles
├── mindmaps/
├── diagrams/
│ ├── ownership-timeline.txt
│ ├── borrow-rules.txt
│ └── memory-layout.txt
└── printables/
└── cheatsheet-templates.pdf
Note : Les chapitres 31-50 contiennent plusieurs sous-thèmes par numéro de chapitre. Consultez directement le dossier
book/pour la liste complète.
( parce que je trouve sa plus ludique d'apprendre avec exercice plutot que de la theorie encore et encore )
Niveau : 🌱 Débutant
Concepts : println!, variables, types
📂 Voir le projet
Niveau : 🟢 Débutant
Concepts : input/output, match, functions, error handling
📂 Voir le projet
Niveau : 🟡 Intermédiaire
Concepts : TCP sockets, threads, ownership
📂 Voir le projet
Niveau : 🟡 Intermédiaire
Concepts : iterators, closures, file I/O
📂 Voir le projet
Niveau : 🟠 Avancé
Concepts : async/await, event loop, state machine
📂 Voir le projet
Niveau : 🔴 Expert
Concepts : Tokio, databases, authentication
📂 Voir le projet
| Semaine | Chapitres | Focus | Projet |
|---|---|---|---|
| 1 | 1-5 | Installation, bases absolues | Hello World Avancé |
| 2 | 6-11 | Variables, types, contrôle de flux | Calculatrice CLI |
| 3-4 | 12-18 | Ownership, lifetimes, borrowing | - |
| 5 | 19-25 | Structs, enums, traits | - |
| 6 | 26-30 | Génériques, closures, modules | Data Pipeline |
| 7 | 31-35 | Collections, smart pointers | - |
| 8 | 36-40 | Concurrence, async/await, macros | Mini HTTP Server |
| 9 | 41-46 | Unsafe, FFI, testing | - |
| 10 | 47-50 | WASM, embedded, patterns | Web Service |
Temps estimé par jour : 2-3 heures
Validation : Compléter tous les exercices de chaque chapitre
Les contributions sont les bienvenues ! 🎉
- Fork le dépôt
- Créez une branche :
git checkout -b feature/votre-fork - Commit vos changements :
git commit -m 'ajout de votre fork' - Push vers la branche :
git push origin feature/votre-fork - Ouvrez une Pull Request
- Correction de fautes / typos
- Correction de bugs dans les exemples
- Ajout de nouveaux exercices
- Amélioration de la documentation
- Traductions (anglais, espagnol, etc.)
- Diagrammes et visualisations
- Respectez le style de code Rust (
cargo fmt) - Ajoutez des tests pour les nouveaux exemples
- Documentez votre code avec des commentaires clairs
- Suivez la structure existante
Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.
- Email : contact@anonseclab.org
- Discord : Rejoindre le serveur
- 📖 The Rust Book (officiel)
- 🦀 Rust by Example
- 🏋️ Rustlings
- 📺 Let's Get Rusty (YouTube)
- 🗣️ r/rust (Reddit)
- ⭐ Star ce dépôt pour suivre les mises à jour
- Watch pour recevoir des notifications
- Fork pour créer votre version personnalisée
