Glossary
Auto-generated index of key terms and which lesson covers them.
| Term | Lesson |
|---|---|
| A Complete Program | 01. Hello Rust |
| A Struct for the Counts | 25. Build a CLI Tool |
| Accessing Elements | 09. Vec Slices and Strings |
| anyhow and thiserror | 14. Advanced Error Handling |
| Arrays | 03. Data Types |
| Associated Functions | 06. Structs and Methods |
| Async vs Threads | 24. Async and Await |
| Atomic Types | 23. Shared State |
| Awaiting a Future | 24. Async and Await |
| Basic Types Preview | 01. Hello Rust |
| BinaryHeap | 11. Advanced Collections |
| Bounded Collections | 10. HashMap |
| Box |
16. Smart Pointers |
| BTreeMap | 11. Advanced Collections |
| BTreeSet | 11. Advanced Collections |
| Buffered and Unbuffered Channels | 22. Threads and Channels |
| Building and Running | 01. Hello Rust |
| Cancellation with CancellationToken | 24. Async and Await |
| Capacity vs Length | 09. Vec Slices and Strings |
| Capturing Arguments | 21. Macros |
| Capturing Variables | 19. Closures |
| Cargo Tooling | 18. Modules and Crates |
| Cell vs RefCell | 17. Interior Mutability |
| Cell |
17. Interior Mutability |
| Channels vs Shared State: When to Use Which | 22. Threads and Channels |
| Channels: Message Passing | 22. Threads and Channels |
| Choosing Between String and &str | 09. Vec Slices and Strings |
| Choosing the Right Collection | 11. Advanced Collections |
| Clone: Explicit Deep Copy | 05. Ownership and Borrowing |
| Closure Syntax | 19. Closures |
| Collecting Iterators into Collections | 10. HashMap |
| Command-Line Arguments | 25. Build a CLI Tool |
| Comments | 01. Hello Rust |
| Common Crates to Know | 18. Modules and Crates |
| Common Lifetime Errors and Fixes | 15. Lifetimes |
| Common Standard Library Traits | 12. Traits |
| Compiling Without Cargo | 01. Hello Rust |
| const vs let | 02. Variables and Mutability |
| Consumers | 20. Iterators |
| Counting with Iterators | 25. Build a CLI Tool |
| Crates Worth Learning | 26. What's Next |
| Creating a Project with Cargo | 01. Hello Rust |
| Creating Instances | 06. Structs and Methods |
| Creating Iterators | 20. Iterators |
| Custom Error Types | 14. Advanced Error Handling |
| Dangling References: Impossible in Rust | 05. Ownership and Borrowing |
| Debug Printing with {:?} | 01. Hello Rust |
| Deduplication with HashSet | 11. Advanced Collections |
| Default in Practice | 12. Traits |
| Default Methods | 12. Traits |
| Defining a Trait | 12. Traits |
| Defining Structs | 06. Structs and Methods |
| Deref and Drop | 16. Smart Pointers |
| Enum Methods | 07. Enums and Pattern Matching |
| Enums with Variants | 07. Enums and Pattern Matching |
| Error Handling with Result and ? | 25. Build a CLI Tool |
| Error Propagation Chain | 14. Advanced Error Handling |
| Explicit Type Annotations | 02. Variables and Mutability |
| Extending the Tool | 25. Build a CLI Tool |
| External Crates and Cargo.toml | 18. Modules and Crates |
| Field Init Shorthand | 06. Structs and Methods |
| File Structure Conventions | 18. Modules and Crates |
| File-Based Modules | 18. Modules and Crates |
| Floats, Booleans, and Chars | 03. Data Types |
| Formatting the Output | 25. Build a CLI Tool |
| Function Signatures | 04. Functions and Control Flow |
| Functions That Accept Functions | 19. Closures |
| Generic Functions | 13. Generics |
| Generic Structs and Enums | 13. Generics |
| Growable Arrays with Vec | 09. Vec Slices and Strings |
| HashSet | 11. Advanced Collections |
| How the Concepts Connect | 25. Build a CLI Tool |
| if let for Single Patterns | 07. Enums and Pattern Matching |
| If/Else as an Expression | 04. Functions and Control Flow |
| Immutable Bindings with let | 02. Variables and Mutability |
| Implementing Traits | 12. Traits |
| Implicit Return | 04. Functions and Control Flow |
| Inline Modules with mod | 18. Modules and Crates |
| Installing Rust | 01. Hello Rust |
| Integer Overflow | 03. Data Types |
| Integer Types | 03. Data Types |
| Iterator Adaptors | 20. Iterators |
| Key-Value Storage with HashMap | 10. HashMap |
| Lifetime Annotations on Functions | 15. Lifetimes |
| Lifetime Elision Rules | 15. Lifetimes |
| Lifetimes in Structs | 15. Lifetimes |
| Loop with Break Returning a Value | 04. Functions and Control Flow |
| Loops: loop, while, for | 04. Functions and Control Flow |
| Macro Delimiters | 21. Macros |
| macro_rules! | 21. Macros |
| Macros You Already Know | 21. Macros |
| Map, Filter, Reduce | 20. Iterators |
| Match with Enums | 04. Functions and Control Flow |
| Match with Multiple Patterns and Guards | 04. Functions and Control Flow |
| Match: Pattern Matching | 04. Functions and Control Flow |
| Matching on Result | 08. Error Handling |
| Method Chaining | 20. Iterators |
| Methods with impl Blocks | 06. Structs and Methods |
| Min-Heap with Reverse | 11. Advanced Collections |
| Mixed Workloads: I/O and CPU Together | 24. Async and Await |
| Move Closures for Threads | 22. Threads and Channels |
| Move Semantics | 05. Ownership and Borrowing |
| Multiple Bounds with + | 13. Generics |
| Multiple Error Types | 14. Advanced Error Handling |
| Multiple Patterns | 21. Macros |
| Mutable Bindings with let mut | 02. Variables and Mutability |
| Mutable References | 05. Ownership and Borrowing |
| Mutex Performance and RwLock | 23. Shared State |
| Operator Overloading with Add | 13. Generics |
| Operators | 04. Functions and Control Flow |
| Option and the Absence of Null | 07. Enums and Pattern Matching |
| Ownership and Functions | 05. Ownership and Borrowing |
| Owning a Slice | 09. Vec Slices and Strings |
| panic! vs Recoverable Errors | 08. Error Handling |
| PartialEq vs Eq | 12. Traits |
| Pattern Matching with match | 07. Enums and Pattern Matching |
| Practical Example: Parallel Worker Pattern | 22. Threads and Channels |
| Practice Alongside (Every Week) | 26. What's Next |
| Printing with println! | 01. Hello Rust |
| Priority Queue with Structs | 11. Advanced Collections |
| Project Setup | 25. Build a CLI Tool |
| Project Structure | 01. Hello Rust |
| pub Visibility | 18. Modules and Crates |
| Push, Pop, and Iteration | 09. Vec Slices and Strings |
| Range Queries with BTreeMap | 11. Advanced Collections |
| Ranges | 04. Functions and Control Flow |
| Rayon: Easy Parallelism | 23. Shared State |
| Rc<RefCell |
17. Interior Mutability |
| Rc |
16. Smart Pointers |
| Re-exporting with pub use | 18. Modules and Crates |
| Reading the File | 25. Build a CLI Tool |
| RefCell |
17. Interior Mutability |
| References: Borrowing Without Ownership | 05. Ownership and Borrowing |
| Removing Elements | 09. Vec Slices and Strings |
| Returning impl Trait | 12. Traits |
| Running Futures Concurrently | 24. Async and Await |
| Running the Tool | 25. Build a CLI Tool |
| Send and Sync Traits | 23. Shared State |
| Set Operations | 11. Advanced Collections |
| Shadowing | 02. Variables and Mutability |
| Shared State: Arc and Mutex | 23. Shared State |
| Shutdown Signals | 22. Threads and Channels |
| Slicing | 09. Vec Slices and Strings |
| Spawning Tasks | 24. Async and Await |
| Spawning Threads | 22. Threads and Channels |
| String vs &str | 03. Data Types |
| Strings: Owned vs Borrowed | 09. Vec Slices and Strings |
| The ? Operator | 08. Error Handling |
| The 'static Lifetime | 15. Lifetimes |
| The Borrow Checker Summary | 05. Ownership and Borrowing |
| The Complete Program | 25. Build a CLI Tool |
| The Copy Trait: Stack Types Are Different | 05. Ownership and Borrowing |
| The Crate Root: lib.rs vs main.rs | 18. Modules and Crates |
| The Derive Macro | 12. Traits |
| The Double Reference Problem | 20. Iterators |
| The Entry API | 10. HashMap |
| The Gap Between Learning and Doing | 26. What's Next |
| The Iterator Trait | 20. Iterators |
| The move Keyword | 19. Closures |
| The One Mutable Reference Rule | 05. Ownership and Borrowing |
| The Result<T, E> Enum | 08. Error Handling |
| The Three Ownership Rules | 05. Ownership and Borrowing |
| The Tokio Runtime | 24. Async and Await |
| Threading Equivalents | 17. Interior Mutability |
| Three Kinds of impl | 13. Generics |
| Trait Bounds | 13. Generics |
| Traits as Parameters | 12. Traits |
| Tuple Structs | 06. Structs and Methods |
| Tuples | 03. Data Types |
| Type Inference | 02. Variables and Mutability |
| Unit Structs | 06. Structs and Methods |
| unwrap and expect | 08. Error Handling |
| use Statements | 18. Modules and Crates |
| UTF-8 String Indexing | 09. Vec Slices and Strings |
| Variadic Macros | 21. Macros |
| VecDeque | 11. Advanced Collections |
| VecDeque as Queue and Stack | 11. Advanced Collections |
| Weak |
16. Smart Pointers |
| Weeks 1-2: Fluency (Stop Fighting the Compiler) | 26. What's Next |
| Weeks 11-12: One Serious Project | 26. What's Next |
| Weeks 3-4: Real Tooling | 26. What's Next |
| Weeks 5-6: Concurrency | 26. What's Next |
| Weeks 7-8: Networking | 26. What's Next |
| Weeks 9-10: Production Patterns | 26. What's Next |
| What Are Macros | 21. Macros |
| What Is a Future | 24. Async and Await |
| When the Compiler Can't Figure It Out | 15. Lifetimes |
| When to Use Macros | 21. Macros |
| Where Clauses | 13. Generics |
| Workspaces | 18. Modules and Crates |
| Your First Program | 01. Hello Rust |
| Zero-Cost Abstraction | 20. Iterators |