Variables & Immutability — Why Ruby's Free Reassignment Disappears

In Ruby, x = 10 can become x = 20 at any time. Rust is different. let x = 10; makes this value immutable. Try to change it and you get a compile error.

let x = 10;
// x = 20;  // error[E0384]: cannot assign twice to immutable variable

Think of Ruby's freeze applied to every variable by default.

mut — explicit mutability

Want to change a value? Add mut.

let mut x = 10;
x = 20;  // OK

It tells the reader "this variable will change." In Ruby, every variable is implicitly mut. Rust demands you state your intent.

shadowing — redeclaring with the same name

In Ruby, x = "hello" can become x = 42 — even changing types. Rust's equivalent is shadowing.

let x = "hello";  // &str
let x = x.len();  // usize — type change is fine
let x = x + 1;    // shadows previous x

The difference from mut: shadowing creates a new variable. The previous x is gone. mut changes the value of the same variable.

// mut can't change the type
let mut x = "hello";
// x = 5;  // compile error! type mismatch

// shadowing can change the type
let x = "hello";
let x = 5;  // OK — new variable

Shadowing feels more natural to Rubyists. It's common in Rust too — especially when parsing a string into a number and reusing the same name.

const — Ruby's CONSTANT

Like Ruby's MAX_SIZE = 100, Rust uses const for constants.

const MAX_SIZE: usize = 100;

Differences from let:

• const requires explicit type annotation

• const values must be known at compile time

• const works anywhere (outside functions too)

In Ruby, reassigning a constant gives a warning but runs. In Rust, const reassignment is impossible.

Summary