| Arc<T> | Atomically reference-counted smart pointer for shared ownership of data across threads. |
| async/await | Keywords used to write asynchronous code that is non-blocking and efficient. |
| Attribute (`#[...]`) | Metadata applied to items like functions or structs to affect compilation or behavior. |
| Borrowing | Accessing data without taking ownership, either immutably (&T) or mutably (&mut T). |
| Box<T> | A smart pointer for heap allocation and ownership transfer. |
| Cargo | Rust’s official build system and package manager. |
| Channel | Message-passing primitive for thread communication; provided by std::sync::mpsc. |
| Clone | A trait for making deep copies of data. |
| Closure | An anonymous function that can capture variables from its enclosing scope. |
| Conversion | Type conversion via From, Into, TryFrom, and TryInto traits. |
| Copy | Marker trait for types whose values are bitwise-copied rather than moved on assignment. |
| Crate | A compilation unit in Rust; can be a library or executable. |
| Data Structure | Standard collections including Vec<T>, HashMap, BTreeMap, and VecDeque from std::collections. |
| Derive | Automatically implements traits using attributes like #[derive(Debug)]. |
| Drop | A trait for customizing what happens when a value goes out of scope. |
| Enum | A type that can be one of several defined variants, useful in pattern matching. |
| Error Handling | Primarily done through Result<T, E> and panic!. |
| Fat Pointer | A pointer with additional metadata (e.g., for slices or trait objects). |
| File I/O | Reading and writing files using std::fs and types like File and BufReader. |
| for loop | Iterates over a range or any type implementing IntoIterator. |
| Function Pointer | A reference to a function, e.g., fn(). |
| Generics | Parametric types/functions using type parameters like <T>. |
| HashMap | A key-value collection from std::collections. |
| Heap | Memory allocated dynamically during runtime. |
| impl | Defines method implementations or trait implementations for a type. |
| Interior Mutability | Pattern allowing mutation through a shared reference, using Cell<T> or RefCell<T>. |
| IntoIterator | A trait used in for loops to produce iterators from a value. |
| Iterator | A trait providing next() for sequential element access; the basis of Rust's lazy iteration model. |
| Lifetime ('a) | Specifies how long a reference is valid. |
| Loop | An infinite loop construct, terminated using break. |
| Macro | Metaprogramming feature used to generate code (e.g., macro_rules!). |
| Match | Pattern matching construct used for branching logic. |
| Method | Function defined in an impl block and called via . on a value or reference. |
| Module (mod) | Namespace construct for organizing code. |
| Move Semantics | Transfer of ownership when a non-Copy value is assigned or passed to a function. |
| Mutex | Synchronization primitive ensuring exclusive access to shared data across threads. |
| Option<T> | Enum representing an optional value: Some(T) holds a value, None represents absence. |
| Ownership | Each value has a single owner responsible for its lifetime and cleanup. |
| Pattern Matching | Used to destructure data using match, if let, or while let. |
| Pointer | A reference to data, either safe (&T) or raw (*const T). |
| Rc<T> | Reference-counted smart pointer for shared ownership in single-threaded contexts. |
| Reference | A non-owning pointer to a value, subject to borrowing rules. |
| Regular Expression | Pattern matching on strings via the regex crate. |
| Result<T, E> | Enum used to represent success (Ok) or error (Err) states. |
| Shadowing | Rebinding a variable with a new value and possibly a new type. |
| Slice | A view into a sequence of elements, e.g., &[T]. |
| String | Growable, heap-allocated UTF-8 text. |
| Struct | A custom type composed of named fields. |
| Thread | Unit of concurrent execution spawned via std::thread::spawn. |
| Trait | A collection of method signatures that a type can implement. |
| Trait Object | A dynamically dispatched instance of a trait, e.g., Box<dyn Trait>. |
| Tuple | A fixed-size collection of values of various types, e.g., (i32, f64). |
| Type Inference | Compiler deduction of variable types from context, enabling let x = 5 without an explicit annotation. |
| Unit Test | Test function marked #[test], collected and run by cargo test. |
| Unsafe | Marks code blocks that can bypass Rust’s safety checks. |
| Vec<T> | A growable, heap-allocated array type. |
| Variable Binding (let) | Declares variables; may be mutable with let mut. |
| Zero-cost Abstractions | Rust abstractions incur no runtime overhead compared to equivalent low-level code. |