Rust

Rust basics : variables (let, mut), types primitifs, functions, modules

Ownership : move semantics, borrowing, references (&, &mut), lifetimes

Borrowing rules : une seule &mut OU plusieurs &, no dangling references

Structs, enums, pattern matching et destructuring

Traits : définition, implémentation, trait bounds, derive macros

Generics : functions, structs, enums génériques avec trait bounds

Lifetimes : annotations ('a), lifetime elision, static lifetime

Error handling : Result<T, E>, Option<T>, ? operator, panic vs Result

Collections : Vec, HashMap, HashSet, iterators et méthodes (map, filter, collect)

Iterators : Iterator trait, lazy evaluation, combinators, for loops

Ownership patterns : Clone vs Copy, Rc/Arc, RefCell/Mutex pour interior mutability

Concurrency : threads, Arc<Mutex<T>>, channels (mpsc), Send/Sync traits

Async/await : Future trait, async fn, .await, Tokio runtime, async tasks

Axum/Actix-web : routing, handlers, extractors, middleware, state management

Database : sqlx (compile-time checking), Diesel ORM, async queries

Serialization : serde (Serialize, Deserialize), JSON, derive macros

Testing : #[test], #[cfg(test)], assert!, integration tests, mocking

Macros : declarative macros (macro_rules!), procedural macros, derive

Memory safety : no null pointers, no buffer overflows, thread safety

Performance : zero-cost abstractions, inlining, LLVM optimizations, profiling

Cargo : dependencies (Cargo.toml), features, workspaces, build scripts

Deployment : cross-compilation, Docker, static binaries, release profiles