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 | 16. Build a CLI Tool |
| Accessing Elements | 08. Collections |
| anyhow and thiserror | 07. Error Handling |
| Arrays | 03. Data Types |
| Associated Functions | 06. Structs and Enums |
| Async vs Threads | 15. Async and Await |
| Awaiting a Future | 15. Async and Await |
| Basic Types Preview | 01. Hello Rust |
| Building and Running | 01. Hello Rust |
| Capacity vs Length | 08. Collections |
| Capturing Variables | 13. Closures and Iterators |
| Channels vs Mutex: When to Use Which | 14. Concurrency |
| Channels: Message Passing | 14. Concurrency |
| Choosing Between String and &str | 08. Collections |
| Clone: Explicit Deep Copy | 05. Ownership and Borrowing |
| Closure Syntax | 13. Closures and Iterators |
| Collecting Iterators into Collections | 08. Collections |
| Combining Structs and Enums | 06. Structs and Enums |
| Command-Line Arguments | 16. Build a CLI Tool |
| Comments | 01. Hello Rust |
| Common Crates to Know | 12. Modules and Crates |
| Common Lifetime Errors and Fixes | 11. Lifetimes |
| Common Standard Library Traits | 09. Traits |
| const vs let | 02. Variables and Mutability |
| Consumers | 13. Closures and Iterators |
| Counting with Iterators | 16. Build a CLI Tool |
| Creating a Project with Cargo | 01. Hello Rust |
| Creating Instances | 06. Structs and Enums |
| Creating Iterators | 13. Closures and Iterators |
| Custom Error Types | 07. Error Handling |
| Dangling References: Impossible in Rust | 05. Ownership and Borrowing |
| Default Methods | 09. Traits |
| Defining a Trait | 09. Traits |
| Defining Structs | 06. Structs and Enums |
| Enums with Variants | 06. Structs and Enums |
| Error Handling with Result and ? | 16. Build a CLI Tool |
| Error Propagation Chain | 07. Error Handling |
| Explicit Type Annotations | 02. Variables and Mutability |
| Extending the Tool | 16. Build a CLI Tool |
| External Crates and Cargo.toml | 12. Modules and Crates |
| Field Init Shorthand | 06. Structs and Enums |
| File Structure Conventions | 12. Modules and Crates |
| File-Based Modules | 12. Modules and Crates |
| Floats, Booleans, and Chars | 03. Data Types |
| Formatting the Output | 16. Build a CLI Tool |
| Function Signatures | 04. Functions and Control Flow |
| Generic Structs and Enums | 10. Generics |
| Growable Arrays with Vec | 08. Collections |
| Heap-Allocated Strings | 08. Collections |
| How the Concepts Connect | 16. Build a CLI Tool |
| if let for Single Patterns | 06. Structs and Enums |
| If/Else as an Expression | 04. Functions and Control Flow |
| Immutable Bindings with let | 02. Variables and Mutability |
| Implementing Traits | 09. Traits |
| Implicit Return | 04. Functions and Control Flow |
| Inline Modules with mod | 12. Modules and Crates |
| Installing Rust | 01. Hello Rust |
| Integer Types | 03. Data Types |
| Iterator Adaptors | 13. Closures and Iterators |
| Key-Value Storage with HashMap | 08. Collections |
| Lifetime Annotations on Functions | 11. Lifetimes |
| Lifetime Elision Rules | 11. Lifetimes |
| Lifetimes in Structs | 11. Lifetimes |
| Loop with Break Returning a Value | 04. Functions and Control Flow |
| Loops: loop, while, for | 04. Functions and Control Flow |
| 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 | 07. Error Handling |
| Method Chaining | 13. Closures and Iterators |
| Methods with impl Blocks | 06. Structs and Enums |
| Move Closures for Threads | 14. Concurrency |
| Move Semantics | 05. Ownership and Borrowing |
| Multiple Bounds with + | 10. Generics |
| Multiple Error Types | 07. Error Handling |
| Mutable Bindings with let mut | 02. Variables and Mutability |
| Mutable References | 05. Ownership and Borrowing |
| Option and the Absence of Null | 06. Structs and Enums |
| Ownership and Functions | 05. Ownership and Borrowing |
| panic! vs Recoverable Errors | 07. Error Handling |
| Pattern Matching with match | 06. Structs and Enums |
| Practical Example: Parallel Web Scraper Pattern | 14. Concurrency |
| Printing with println! | 01. Hello Rust |
| Project Setup | 16. Build a CLI Tool |
| Project Structure | 01. Hello Rust |
| pub Visibility | 12. Modules and Crates |
| Push, Pop, and Iteration | 08. Collections |
| Ranges | 04. Functions and Control Flow |
| Rayon: Easy Parallelism | 14. Concurrency |
| Re-exporting with pub use | 12. Modules and Crates |
| Reading the File | 16. Build a CLI Tool |
| References: Borrowing Without Ownership | 05. Ownership and Borrowing |
| Returning impl Trait | 09. Traits |
| Running Futures Concurrently | 15. Async and Await |
| Running the Tool | 16. Build a CLI Tool |
| Send and Sync Traits | 14. Concurrency |
| Shadowing | 02. Variables and Mutability |
| Shared State: Arc and Mutex | 14. Concurrency |
| Spawning Tasks | 15. Async and Await |
| Spawning Threads | 14. Concurrency |
| String vs &str | 03. Data Types |
| The ? Operator | 07. Error Handling |
| The 'static Lifetime | 11. Lifetimes |
| The Borrow Checker Summary | 05. Ownership and Borrowing |
| The Complete Program | 16. Build a CLI Tool |
| The Copy Trait: Stack Types Are Different | 05. Ownership and Borrowing |
| The Crate Root: lib.rs vs main.rs | 12. Modules and Crates |
| The Derive Macro | 09. Traits |
| The Entry API | 08. Collections |
| The Iterator Trait | 13. Closures and Iterators |
| The move Keyword | 13. Closures and Iterators |
| The One Mutable Reference Rule | 05. Ownership and Borrowing |
| The Result<T, E> Enum | 07. Error Handling |
| The Three Ownership Rules | 05. Ownership and Borrowing |
| The Tokio Runtime | 15. Async and Await |
| Trait Bounds | 10. Generics |
| Traits as Parameters | 09. Traits |
| Tuple Structs | 06. Structs and Enums |
| Tuples | 03. Data Types |
| Type Inference | 02. Variables and Mutability |
| unwrap and expect | 07. Error Handling |
| use Statements | 12. Modules and Crates |
| UTF-8 String Indexing | 08. Collections |
| What Is a Future | 15. Async and Await |
| When the Compiler Can't Figure It Out | 11. Lifetimes |
| Where Clauses | 10. Generics |
| Workspaces | 12. Modules and Crates |
| Your First Program | 01. Hello Rust |
| Zero-Cost Abstraction | 13. Closures and Iterators |