Rust Glossary

Browse 43 rust terms defined in plain English, from the cultural dictionary of computing.

43 Rust Terms

Biome
A fast, all-in-one code formatter and linter for JavaScript, TypeScript, JSON, and CSS, written in Rust. Biome is the successor to Rome (an ambitious project...
Borrowing
In Rust's ownership system, temporarily accessing data owned by another variable without taking ownership — via immutable (&T) or mutable (&mut T) references —...
Cargo
The official build system and package manager for Rust, handling dependency resolution, compilation, testing, benchmarking, documentation generation, and...
Crate
A Rust compilation unit and package boundary that can produce a library or executable and can be published through the Rust ecosystem. Crates define code...
Discriminant
A tag or value that indicates which variant of a union or enum type is currently active. In Rust, every enum variant has an implicit discriminant; in...
Lifetime
In Rust, a compile-time annotation that tracks how long a reference is valid, preventing dangling pointers and use-after-free bugs without a garbage...
Match Expression
A control-flow construct that compares a value against a series of patterns and executes the arm of the first match. Unlike switch statements, match...
Monomorphization
A compile-time code generation strategy — used by Rust, C++ templates, and similar languages — that creates a specialized copy of each generic function or type...
Mutable
Describing a value or variable whose contents can be changed after creation — the default in most imperative languages but an explicit opt-in (e.g., `mut` in...
Newtype
A pattern (and keyword in Haskell) for creating a distinct type that wraps an existing type with zero runtime overhead, providing type safety by preventing...
Option
A sum type (called `Option<T>` in Rust, `Optional<T>` in Java/Swift, and `Maybe a` in Haskell) that explicitly represents the presence (`Some(value)`) or...
Ownership
A memory management model, most prominently used in Rust, where each value has a single owner variable. When the owner goes out of scope the value is dropped....
Panic
An unrecoverable runtime error that immediately unwinds (or aborts) the current thread or goroutine, used in Go and Rust when a program reaches a state that is...
Raw Pointer
A pointer type (*const T or *mut T in Rust, bare pointers in C/C++) that carries no ownership semantics, lifetime guarantees, or automatic null/bounds...
Result Type
An algebraic type that represents either a success value or an error, forcing callers to explicitly handle both outcomes at compile time instead of relying on...
Rspack
A Rust-based JavaScript bundler designed as a drop-in replacement for Webpack, offering 5-10x faster build times while maintaining compatibility with the...
Rust Analyzer
The language-server implementation and analysis engine used to power Rust editor support such as completion and diagnostics.
Rust Borrow Checker
The component of the Rust compiler that enforces ownership and borrowing rules at compile time: a value can have either one mutable reference or any number of...
Rust Community
The ecosystem of developers, maintainers, educators, and tool builders working with Rust and its surrounding tools. In programming culture, the Rust community...
Rust Crate
The unit of compilation and distribution in Rust, either a binary (executable) or a library. Crates are published to crates.io, managed by Cargo, and declared...
Rust Edition
A Rust language edition, which groups language and tooling changes under a compatibility-managed milestone without fracturing the ecosystem into incompatible...
Rust Lifetime
A compile-time annotation (written as 'a) that tells the Rust compiler how long a reference is valid, enabling it to prove that references never outlive the...
Rust Macro
A metaprogramming construct in Rust that generates code at compile time. Declarative macros (macro_rules!) match patterns and expand to code, while procedural...
Rust Toolchain
The set of Rust development tools used together, typically including the compiler, Cargo, standard library, and associated components. In engineering practice,...
Rust Trait
A named set of method signatures (and optionally default implementations) that types can implement to satisfy a shared interface. Traits enable bounded...
Rust Unsafe
A Rust keyword that unlocks five additional capabilities the compiler cannot verify: dereferencing raw pointers, calling unsafe functions (including FFI),...
Send
In Rust, a marker trait indicating that a type can be safely transferred across thread boundaries; if a type is `Send`, ownership can move to another thread...
Slice
A lightweight view into a contiguous region of an array or buffer, typically represented as a pointer, a length, and optionally a capacity — without copying...
Smart Pointer
A data structure that wraps a raw pointer, providing automatic memory management through reference counting or ownership semantics, such as C++ unique_ptr,...
Stack Unwinding
The process by which the runtime walks back up the call stack after an exception is thrown (or a panic occurs), calling destructors for all local objects in...
Static Dispatch
A method call resolution strategy where the compiler determines the exact function to invoke at compile time, typically through monomorphization of generics,...
Tagged Union
A data type that can hold a value from a fixed set of variants, each potentially carrying different associated data, with a tag (discriminant) indicating which...
Tauri
A framework for building lightweight, secure desktop applications using web technologies (HTML, CSS, JavaScript) with a Rust backend. Unlike Electron, which...
Trait
A language construct that defines shared behavior as a set of method signatures (and optionally default implementations) that types can implement. Used in...
Turbopack
A Rust-based JavaScript bundler developed by Vercel as the successor to Webpack, designed to be dramatically faster through incremental computation and native...
Unsafe
A keyword in Rust (and similar languages) that opts out of certain compiler safety guarantees, allowing raw pointer dereferences, FFI calls, and other...
Unwrap
An operation that extracts the inner value from a wrapper type such as Option or Result, panicking or throwing if the wrapper contains no value (None) or an...
Variable Shadowing
The situation where a variable declared in an inner scope has the same name as one in an outer scope, effectively hiding the outer variable within that block....
Waker
In Rust's async runtime model, a handle provided to a Future when it is polled that the future stores and later uses to signal the executor that it is ready to...
Warp
A lightweight, composable web framework for Rust built on top of hyper, where routes and middleware are modeled as combinable Filters that can be chained with...
Weak Pointer
A non-owning reference to a resource managed by reference counting (such as std::weak_ptr in C++ or Weak<T> in Rust) that does not prevent the resource from...
Yew
A Rust framework for building client-side web applications that compile to WebAssembly, offering a component-based architecture inspired by React and Elm with...
Zola
A static-site generator written in Rust, used for blogs, docs, and fast content sites.

Related Topics