Glossary
Auto-generated index of key terms and which lesson covers them.
| Term | Lesson |
|---|---|
| &str vs String — When to Use Which | 07. Collections |
| Accessing Elements | 07. Collections |
| anyhow and thiserror | 06. Error Handling |
| Associated Functions | 05. Structs and Enums |
| Async/Await and Tokio | 12. Concurrency |
| Basic Types Preview | 01. Hello Rust |
| Building and Running | 01. Hello Rust |
| Capacity vs Length | 07. Collections |
| Capturing Variables | 11. Closures and Iterators |
| Channels vs Mutex: When to Use Which | 12. Concurrency |
| Channels: Message Passing | 12. Concurrency |
| Clone: Explicit Deep Copy | 04. Ownership and Borrowing |
| Closure Syntax | 11. Closures and Iterators |
| Collecting Iterators into Collections | 07. Collections |
| Combining Structs and Enums | 05. Structs and Enums |
| Comments | 01. Hello Rust |
| Common Crates to Know | 10. Modules and Crates |
| Common Lifetime Errors and Fixes | 09. Lifetimes |
| Common Standard Library Traits | 08. Traits and Generics |
| Compound Types — Arrays | 02. Variables and Types |
| Compound Types — Tuples | 02. Variables and Types |
| const vs let | 02. Variables and Types |
| Consumers | 11. Closures and Iterators |
| Creating a Project with Cargo | 01. Hello Rust |
| Creating Instances | 05. Structs and Enums |
| Creating Iterators | 11. Closures and Iterators |
| Custom Error Types | 06. Error Handling |
| Dangling References: Impossible in Rust | 04. Ownership and Borrowing |
| Default Methods | 08. Traits and Generics |
| Defining a Trait | 08. Traits and Generics |
| Defining Structs | 05. Structs and Enums |
| Enums with Variants | 05. Structs and Enums |
| Error Propagation Chain | 06. Error Handling |
| Explicit Type Annotations | 02. Variables and Types |
| External Crates and Cargo.toml | 10. Modules and Crates |
| Field Init Shorthand | 05. Structs and Enums |
| File Structure Conventions | 10. Modules and Crates |
| File-Based Modules | 10. Modules and Crates |
| Function Signatures | 03. Functions and Control Flow |
| Generics in Structs and Enums | 08. Traits and Generics |
| HashMap<K, V> — Key-Value Storage | 07. Collections |
| if let for Single Patterns | 05. Structs and Enums |
| If/Else as an Expression | 03. Functions and Control Flow |
| Implementing Traits | 08. Traits and Generics |
| Implicit Return | 03. Functions and Control Flow |
| Installing Rust | 01. Hello Rust |
| Iterator Adaptors | 11. Closures and Iterators |
| let — Immutable by Default | 02. Variables and Types |
| let mut — Opting Into Mutation | 02. Variables and Types |
| Lifetime Annotations on Functions | 09. Lifetimes |
| Lifetime Elision Rules | 09. Lifetimes |
| Lifetimes in Structs | 09. Lifetimes |
| Loop with Break Returning a Value | 03. Functions and Control Flow |
| Loops: loop, while, for | 03. Functions and Control Flow |
| Match with Enums | 03. Functions and Control Flow |
| Match with Multiple Patterns and Guards | 03. Functions and Control Flow |
| Match: Pattern Matching | 03. Functions and Control Flow |
| Matching on Result | 06. Error Handling |
| Method Chaining | 11. Closures and Iterators |
| Methods with impl Blocks | 05. Structs and Enums |
| Move Closures for Threads | 12. Concurrency |
| Move Semantics | 04. Ownership and Borrowing |
| Multiple Bounds with + | 08. Traits and Generics |
| Multiple Error Types | 06. Error Handling |
| Mutable References | 04. Ownership and Borrowing |
| Option |
05. Structs and Enums |
| Ownership and Functions | 04. Ownership and Borrowing |
| panic! vs Recoverable Errors | 06. Error Handling |
| Pattern Matching with match | 05. Structs and Enums |
| Practical Example: Parallel Web Scraper Pattern | 12. Concurrency |
| println! — The Print Macro | 01. Hello Rust |
| Project Structure | 01. Hello Rust |
| pub Visibility | 10. Modules and Crates |
| Push, Pop, and Iteration | 07. Collections |
| Putting It All Together | 01. Hello Rust |
| Ranges | 03. Functions and Control Flow |
| Rayon: Easy Parallelism | 12. Concurrency |
| Re-exporting with pub use | 10. Modules and Crates |
| References: Borrowing Without Ownership | 04. Ownership and Borrowing |
| Returning impl Trait | 08. Traits and Generics |
| Scalar Types — Floats, Bool, Char | 02. Variables and Types |
| Scalar Types — Integers | 02. Variables and Types |
| Send and Sync Traits | 12. Concurrency |
| Shadowing | 02. Variables and Types |
| Shared State: Arc and Mutex | 12. Concurrency |
| Spawning Threads | 12. Concurrency |
| String — Heap-Allocated Text | 07. Collections |
| String Types — &str vs String | 02. Variables and Types |
| The ? Operator | 06. Error Handling |
| The 'static Lifetime | 09. Lifetimes |
| The Borrow Checker Summary | 04. Ownership and Borrowing |
| The Copy Trait: Stack Types Are Different | 04. Ownership and Borrowing |
| The Crate Root: lib.rs vs main.rs | 10. Modules and Crates |
| The Derive Macro | 08. Traits and Generics |
| The Entry API | 07. Collections |
| The Iterator Trait | 11. Closures and Iterators |
| The mod Keyword — Inline Modules | 10. Modules and Crates |
| The move Keyword | 11. Closures and Iterators |
| The One Mutable Reference Rule | 04. Ownership and Borrowing |
| The Result<T, E> Enum | 06. Error Handling |
| The Three Ownership Rules | 04. Ownership and Borrowing |
| Trait Bounds | 08. Traits and Generics |
| Traits as Parameters | 08. Traits and Generics |
| Tuple Structs | 05. Structs and Enums |
| Type Inference | 02. Variables and Types |
| unwrap and expect | 06. Error Handling |
| use Statements | 10. Modules and Crates |
| UTF-8 and Why You Can't Index by Character | 07. Collections |
| Vec |
07. Collections |
| When the Compiler Can't Figure It Out | 09. Lifetimes |
| Where Clauses | 08. Traits and Generics |
| Workspaces | 10. Modules and Crates |
| Your First Program | 01. Hello Rust |
| Zero-Cost Abstraction | 11. Closures and Iterators |