Tuples and tuple patterns
char, integer widths, as casts and integer bounds
Floating-point numbers with f64
Match guards, range patterns and @ bindings
while let, let-else, labeled loops and break with a value
© 2026 Dometrain. All rights reserved.
Learn how to write Rust, from borrowing and lifetimes to traits, shared ownership, and concurrency.
Rust’s strict compiler and unique memory model can be notoriously difficult to master, even for experienced engineers coming from other languages. This course deconstructs Rust’s core mechanics and advanced features, building your intuition for how the language actually operates under the hood. You will start by mastering advanced control flow and pattern matching, covering everything from match guards and @ bindings to while let, let-else, and labeled loops. From there, we tackle Rust’s most infamous hurdle: borrowing and lifetimes. You will learn exactly how to handle slices, lifetime elision, and explicit lifetime parameters, including how to safely return references to struct fields. With memory safety established, the course moves into building robust abstractions using traits and generics. You will implement Display, hand-roll operators and equality, and write generic functions using trait bounds, where clauses, and impl Trait, alongside standard conversion traits like From, Into, and Default.
Next, you will explore Rust’s functional features through closures and iterators, examining capture semantics, move closures, and how to chain methods like map, filter, zip, and chain before implementing the Iterator trait for your own types. We then cover the standard collections, including the HashMap entry API and BTreeMap, before diving into dynamic dispatch with trait objects and Box. This naturally leads to advanced error handling, where you will build custom error types and leverage impl From so the ? operator converts errors automatically, up to Box. Finally, the course tackles complex memory and concurrency patterns. You will navigate shared ownership and interior mutability using Rc, RefCell, and Weak, and understand exactly when values are dropped via Drop. You will then apply these principles to concurrent programming, utilizing scoped threads, channels, and Arc<Mutex> for shared state, while understanding the Send and Sync traits. Everything culminates in a hands-on capstone project where you will build a threaded batch processor from scratch.
