Rust: What is the difference between let and const?

let — variable binding (can be mutable). const — compile-time constant (always immutable).

let:

• Binds a value to a name in the current scope.
• Can be let mut for mutable variables.
• Value computed at runtime (lazy evaluation).
• Supports destructuring and pattern matching.
• Type is inferred unless annotated.

1let x = 5;              // Immutable
2let mut y = 10;         // Mutable
3y += 5;                 // OK
4
5// Destructuring
6let (name, age) = ("Alice", 30);
7let Point { x, y } = point;
8let &value = &reference;

const:

• Declares a true constant — fixed at compile time.
• Always immutable (no const mut).
• Requires explicit type annotation.
• Can only use const-evaluable expressions.
• Inlined by the compiler — zero runtime cost.

1const MAX_CONNECTIONS: u32 = 100;
2const PI: f64 = 3.14159265358979;
3const COLORS: [u8; 3] = [255, 128, 0];
4
5// const fn for compile-time computation
6const fn factorial(n: u32) -> u32 {
7    match n {
8        0 | 1 => 1,
9        _ => n * factorial(n - 1),
10    }
11}
12const FACT5: u32 = factorial(5);  // 120

When to use:

• Use const for configuration values and compile-time constants.
• Use let for general variables and runtime computations.
• Use static for global values with fixed memory addresses.

Common mistakes:

• Forgetting type annotation on const — compiler requires it.
• Trying to compute const at runtime — must be a constant expression.
• Using static instead of const without understanding the difference.