Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

The unit type in Rust, denoted by (), is a type that possesses exactly one possible value, which is also written as (). In type theory, it is the equivalent of a terminal object; it represents the absence of meaningful data while remaining a concrete, fully-fledged type within Rust’s type system. Unlike void in C or C++, which signifies the absence of a type, () is a valid type that can be instantiated, assigned to variables, and returned from functions.

​
Memory Layout

Because the unit type has only one possible state, it carries no information. Consequently, the Rust compiler treats it as a Zero-Sized Type (ZST). It occupies exactly zero bytes of memory at runtime. 
assert_eq!(std::mem::size_of::<()>(), 0);
Because it requires no memory, arrays composed of the unit type (e.g., [(); N]) consume zero bytes of stack space. For dynamic collections like Vec<()>, the collection will never allocate heap memory for its buffer regardless of the number of elements it holds. However, the collection struct itself still consumes stack space for its internal metadata (such as its pointer, capacity, and length fields).

​
Syntax and Evaluation

The () token serves a dual purpose: it acts as both the type signature and the value itself. 
// Explicitly defining a variable of type `()` and assigning the value `()`
let unit_value: () = ();
Rust’s expression-based syntax heavily relies on the unit type for statement termination. When an expression is terminated with a semicolon (;), the expression is evaluated, its actual result is discarded, and the statement evaluates to (). 
// The block evaluates to `()` because the final expression ends with a semicolon
let result: () = {
    let x = 5;
    x + 1; 
};

​
Function Signatures

Functions in Rust that do not declare an explicit return type implicitly return the unit type. The following two function signatures and their bodies are semantically identical to the compiler: 
// Implicit unit return type
fn implicit_unit() {
    let x = 1;
}

// Explicit unit return type
fn explicit_unit() -> () {
    let x = 1;
    return ();
}
Master Rust with Deep Grasping Methodology!Learn More