Rust Constant Item

const IDENTIFIER: Type = constant_expression;

​

Technical Characteristics

• Explicit Typing: Unlike let bindings, constant items strictly require an explicit type annotation. The Rust compiler does not perform type inference for constant declarations.
• Constant Expressions: The initialization value must be a valid constant expression. This is restricted to operations that can be evaluated at compile time, such as literals, arithmetic operations on other constants, and invocations of const fn (constant functions).
• Memory Semantics: Because constants are inlined, they do not possess a fixed, singular memory address. Taking a reference to a constant (e.g., &MY_CONST) may yield a different memory address at different evaluation sites, depending on compiler optimizations.
• Scoping: Constant items can be declared at any scope level. This includes module-level (global scope), block-level (within functions), or within impl and trait blocks as associated constants.
• Immutability: Constants are inherently and permanently immutable. They cannot be mutated, nor can they be declared with the mut keyword.
• Naming Convention: By convention, constant identifiers must use SCREAMING_SNAKE_CASE. The compiler will emit a warning if this convention is violated.

​

Syntax Visualization

// Module-level constant declaration
const MAX_CAPACITY: usize = 8192;

// Constant initialized via a constant expression and const fn
const fn compute_base() -> u32 {
    42
}
const BASE_VALUE: u32 = compute_base() * 10;

struct Buffer;

impl Buffer {
    // Associated constant within an impl block
    const DEFAULT_SIZE: usize = 1024;
}

fn main() {
    // Block-level constant declaration
    const LOCAL_OFFSET: i32 = -15;
}