Variables, mutability, shadowing and constants

Why are variables fixed by default?

A variable is a name for a value. In most languages, any line can change any variable. In a large program that causes bugs: a value changes somewhere far away and you cannot find where. Rust makes variables immutable by default. Immutable means "cannot be changed". If you want a variable to change, you must say so with mut. Then anyone reading the code knows exactly which values move.

fn main() {
    let price = 100;
    price = 120; // error[E0384]: cannot assign twice to immutable variable
}

fn main() {
    let mut price = 100;
    println!("Old price: {price}");
    price = 120;
    println!("New price: {price}");
}

Types are fixed, even with mut

mut lets the value change, but not the type. A type is the kind of value: a whole number, a decimal number, text and so on. Rust works out the type from the first value; this is called type inference. You can also write the type yourself after a colon.

let mut count: i32 = 5;
count = 6;        // fine: still a number
// count = "six"; // error: expected i32, found &str

Shadowing

Shadowing means writing let again with the same name. This creates a brand-new variable that hides the old one. It is useful when you transform a value step by step, and it can even change the type.

fn main() {
    let input = "  42  ";
    let input = input.trim();          // still text, without spaces
    let input: i32 = input.parse().unwrap(); // now a number
    println!("{}", input + 1);
}

Shadowing also works inside a block (code in curly braces). The inner variable exists only until the closing brace; after it, the outer one is visible again.

let x = 5;
{
    let x = x * 2;
    println!("inside: {x}");  // inside: 10
}
println!("outside: {x}");     // outside: 5

Constants

A constant is a value fixed for the whole program, like a GST rate or the number of seconds in a day. Write it with const, an UPPER_CASE name, and the type is required. Its value must be known when the program is compiled, so it cannot come from user input.

const GST_PERCENT: u32 = 18;
const SECONDS_PER_DAY: u32 = 24 * 60 * 60;

fn main() {
    let price = 500;
    println!("GST: {}", price * GST_PERCENT / 100);
}

There is also static, a value with one fixed place in memory for the whole run. You will rarely need it as a beginner; prefer const.

Names and warnings

• Variables and functions use snake_case: total_price, not totalPrice.
• Constants use SCREAMING_SNAKE_CASE: MAX_USERS.
• An unused variable gives a warning. Start its name with an underscore (_temp) if it is unused on purpose.

Common mistakes

• Adding mut everywhere "just in case". The compiler warns "variable does not need to be mutable". Remove mut when the value never changes.
• Trying to change the type of a mut variable. Use shadowing with a new let instead.
• Writing const without a type, like const RATE = 18;. Add the type: const RATE: u32 = 18;.
• Confusing shadowing with changing: after let x = x + 1; inside a block, the outer x is unchanged.