> ## 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. # Rust Const Function A `const fn` (constant function) in Rust is a function whose body is deterministic and side-effect-free, allowing the compiler to evaluate it entirely at compile time. When invoked within a constant context (such as initializing a `const` or `static` variable, or defining an array length), the function executes during compilation, embedding its return value directly into the final binary. When invoked in a standard context with runtime variables, it executes at runtime exactly like a standard function. ```rust theme={"dark"} // Syntax visualization of a const fn const fn compute_multiplier(base: u32, factor: u32) -> u32 { base * factor } // Compile-time evaluation (Constant Context) const COMPILE_TIME_RESULT: u32 = compute_multiplier(5, 10); fn main() { let runtime_val = 5; // Runtime evaluation (Standard Context) let runtime_result = compute_multiplier(runtime_val, 10); } ``` ## Execution Mechanics The `const` keyword acts as an opt-in contract with the compiler. It guarantees that the function contains no operations that require a runtime environment. The Rust compiler uses an internal interpreter (Miri) to evaluate the Mid-level Intermediate Representation (MIR) of the `const fn` during the compilation phase. During compilation, the Abstract Syntax Tree (AST) is lowered to High-level Intermediate Representation (HIR), then Typed High-level Intermediate Representation (THIR), and finally MIR before this constant evaluation occurs. If the evaluation succeeds, the function call is replaced by the computed constant value. ## Technical Restrictions Because the compiler must be able to execute the function deterministically without depending on the target's runtime environment or host OS facilities, `const fn` bodies are subject to strict semantic limitations: * **No Heap Allocation:** You cannot perform operations that dynamically allocate memory. While you can instantiate types like `String` or `Vec` using their non-allocating constructors (e.g., `String::new()` or `Vec::new()`), actual heap allocations—such as calling `Box::new()`, `Vec::with_capacity()`, or pushing elements into a collection—are strictly prohibited. * **Destructors (`Drop`):** Types with non-trivial destructors cannot be dropped (go out of scope) within a `const fn`. Instantiating them as local variables that drop at the end of the scope will trigger a compilation error (`E0493`). They can only be used if they are returned or leaked. * **No I/O or System Calls:** The function cannot read files, access the network, spawn threads, or interact with the operating system. * **Restricted Function Calls:** A `const fn` can only invoke other functions marked as `const fn`. Calling standard functions, closures, or function pointers is forbidden. * **Control Flow Limitations:** While `if`, `match`, `loop`, and `while` are permitted, `for` loops are prohibited. A `for` loop desugars into `IntoIterator::into_iter`, which relies on trait methods that are not currently evaluable in a constant context. * **Trait Bounds:** Trait bounds on generic parameters are heavily restricted. You cannot call trait methods inside a `const fn` on stable Rust. Users cannot explicitly mark their own trait implementations as `const` to bypass this, as doing so requires the unstable `#![feature(const_trait_impl)]` attribute. * **Floating-Point Operations:** While basic instantiation and returning of floating-point numbers (`f32`, `f64`) are allowed, mathematical operations (addition, subtraction, multiplication, division) on floats are entirely forbidden in stable Rust `const fn` contexts due to cross-platform determinism issues. ## Mutability within `const fn` While `const` implies immutability of the final evaluated value, the internal execution of a `const fn` permits local mutability. ```rust theme={"dark"} const fn calculate_factorial(mut n: u64) -> u64 { let mut result = 1; while n > 1 { result *= n; n -= 1; } result } const fn modify_value(value: &mut u32) { *value += 10; } ``` You may declare `mut` variables, reassign them, and use mutable references (`&mut T`) within the function. Passing `&mut T` as an argument and modifying it within a `const fn` is fully supported and utilizes standard borrow checking. The compile-time restriction applies strictly to the *final evaluated result*: mutable references cannot be part of the final evaluated value of a `const` item. Attempting to return a mutable reference or leak it into the final constant state will trigger a compilation error (`error[E0764]`), as it would violate the guarantees of static, immutable memory.

Tired of Poor Rust Skills? Fix That With Deep Grasping! Learn More