Variables, mutability and types

Same name, different rules

In “Variables, functions and control flow” you saw let and mut through a simple metaphor, without naming shadowing, sized scalar types, or tuples and arrays. Here we pick up the same pieces with the vocabulary and rigor you will use for the rest of the course: which type Rust picks by default, when you have to annotate it yourself, and what actually differs between mutating a value and rebinding a name.

Everything that follows — from structs to iterators — assumes you can tell a let mut apart from shadowing, and that you recognize Rust’s four scalar types. This lesson builds that foundation with code that actually compiles and runs, not just pseudocode.

You will go through five stations: mutability, shadowing, scalar types, fixed-size compound types, and inference. Each one ends with a real example you can run or edit.

STATE · attemptsinitial value: 3
RULE · let mutthe change is declared
RESULT · attempts updatedwithout mut, this would not compile

01 / 05LET · IMMUTABLE BY DEFAULT

Every variable is immutable unless you declare mut

let creates a variable that is immutable by default: once you give it a value, the compiler will not let you reassign it. When a value does need to change — like an attempt counter that goes down each turn — you declare it with mut, a word that makes it visible in the code that this variable is going to change.

Every variable is immutable in Rust unless you explicitly declare mut.

lib.rsCompiles↗

/// Starts with a fixed budget of attempts and consumes one.
#[must_use]
pub fn count_attempts(budget: i32) -> i32 {
    let mut attempts = budget;
    attempts -= 1;
    attempts
}

// Playground entry point for this example.
fn main() {
    println!("attempts left: {}", count_attempts(3));
}

Result

Reassigning without mut is not a style issue: it is a compile error.

lib.rsDoes not compile↗

fn main() {
    let count = 1;
    count = count + 1; // ERROR: cannot assign twice to immutable variable
    println!("{count}");
}

Result

The compiler says (E0384)

cannot assign twice to immutable variable. The compiler points to the first assignment and the reassignment that breaks it.

error[E0384]: cannot assign twice to immutable variable `count`
--> src/main.rs:3:5
|
2 |     let count = 1;
|         ----- first assignment to `count`
3 |     count = count + 1;
|     ^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable `count`
|
help: consider making this binding mutable
|
2 |     let mut count = 1;
|         +++

let can reuse a name with a different type

Writing let again with the same name creates a brand new variable that shadows the previous one. Unlike mut, which changes the stored value without being able to change its type, shadowing can introduce a different type at each step.

In this example, spaces starts as a &str holding three spaces and ends up as a usize, its length. The compiler does not complain because each let creates an independent variable; only the name is reused.

lib.rsCompiles↗

/// Rebinds `spaces` twice: first as `&str`, then as its length.
#[must_use]
pub fn gap_width() -> usize {
    let spaces = "   ";
    let spaces = spaces.len();
    spaces
}

// Playground entry point for this example.
fn main() {
    println!("gap width: {}", gap_width());
}

Result

Rust has four scalar types: integers, floats, bool, and char

A scalar type represents a single value. Rust has four: integers like i32 (with variants of different sizes, signed and unsigned), floating- point numbers like f64 — the default precision —, bool (true or false), and char, a Unicode character. When you write a number with no annotation, i32 and f64 are the types Rust picks by default.

If an operation goes outside the range of its type, a debug build panics; in a release build, the value silently wraps around. That is why it is worth choosing the size with intent, not out of habit, whenever the range of values matters.

lib.rsCompiles↗

/// Returns one value of each scalar type covered in this lesson.
#[must_use]
pub fn describe_trip() -> (i32, f64, bool, char) {
    let distance_km: i32 = 42;
    let precise_km: f64 = 42.195;
    let completed: bool = true;
    let grade: char = 'A';
    (distance_km, precise_km, completed, grade)
}

// Playground entry point for this example.
fn main() {
    let (km, precise_km, completed, grade) = describe_trip();
    println!("{km} {precise_km} {completed} {grade}");
}

Result

Tuples and arrays store several values in a fixed size

A tuple groups several values, even of different types, into one fixed-size compound: checkpoint bundles an f64 distance and a u32 minute count. To get each field back, you destructure it with let and a pattern in parentheses.

An array groups several values of the same type, also with a fixed size, and you reach each position with brackets. Neither the tuple nor the array can grow: a collection that changes size is the job of Vec, which you will see later.

lib.rsCompiles↗

/// Destructures a checkpoint tuple and indexes a fixed-size array of splits.
#[must_use]
pub fn last_split() -> f64 {
    let checkpoint: (f64, u32) = (10.5, 52);
    let (distance_km, _minutes) = checkpoint;
    let splits: [f64; 3] = [5.0, distance_km, 21.1];
    splits[2]
}

// Playground entry point for this example.
fn main() {
    println!("last split: {} km", last_split());
}

Result

Type inference has a limit: ambiguity

Most of the time, Rust infers a variable’s type from how you use it afterward, with no annotation from you. But parse is generic: it can convert text into any numeric type, and if nothing else in the program pins down which one, the compiler runs out of clues.

lib.rsDoes not compile↗

fn main() {
    let laps = "3".parse().unwrap(); // ERROR: type annotations needed
    println!("{laps}");
}

Result

The compiler says (E0284)

type annotations needed. parse is generic and nothing else in the program pins down the target type.

error[E0284]: type annotations needed
--> src/main.rs:2:9
|
2 |     let laps = "3".parse().unwrap();
|         ^^^^       ----- type must be known at this point
|
= note: cannot satisfy `<_ as FromStr>::Err == _`
help: consider giving `laps` an explicit type
|
2 |     let laps: /* Type */ = "3".parse().unwrap();
|             ++++++++++++

Annotating the target, with : u32 or parse::<u32>(), resolves the ambiguity. The rest of the expression keeps getting inferred as usual.

lib.rsCompiles↗

/// Parses a lap count. The `: u32` annotation resolves the ambiguity that
/// `parse` alone cannot: without it, the target integer type is unknown.
///
/// # Panics
///
/// Panics if `raw` is not a valid `u32`.
#[must_use]
pub fn parse_laps(raw: &str) -> u32 {
    let laps: u32 = raw.parse().expect("a valid number of laps");
    laps
}

// Playground entry point for this example.
fn main() {
    println!("laps: {}", parse_laps("3"));
}

Result

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

What changes compared with other languages

Language	Default declaration	How you declare it can change
JavaScript	`let` is mutable by default	Nothing extra needed; `const` does block reassignment
Python	Every variable is reassignable	There is no keyword to mark a variable as immutable
Rust	`let` is immutable by default	You must write `mut` explicitly

The difference is not just syntactic: in Rust, “immutable by default” means the compiler rejects the reassignment before running anything, not that there is a convention you could choose to ignore.

Objective

Complete split_kilometers so it returns (whole_kilometers, remaining_meters) from a total distance in meters.

Implement

Replace `todo!` with the division and remainder of `total_meters` by 1000.

Calculate whole kilometers with `/` and the remaining meters with `%`, and return them as a tuple.

/// Splits a total distance in meters into whole kilometers and the remaining meters.
pub fn split_kilometers(total_meters: u32) -> (u32, u32) {
    todo!("return (total_meters / 1000, total_meters % 1000)")
}

Check

Run three visible cases and use the diagnostic to correct the code.

Visible tests

divides correctly for both exact and non-exact distances

Compiler—

Modify the code before running the tests.

Help

View progressive hints or compare with the solution.

Commented solutionSolution↗

/// Splits a total distance in meters into whole kilometers and the remaining meters.
#[must_use]
pub fn split_kilometers(total_meters: u32) -> (u32, u32) {
    let kilometers = total_meters / 1000;
    let remaining_meters = total_meters % 1000;

    (kilometers, remaining_meters)
}

// Playground entry point for this example.
fn main() {
    let (km, m) = split_kilometers(1500);
    println!("{km} {m}");
}

Result

Summary

let creates variables that are immutable by default; let mut explicitly declares that a variable will change.
Shadowing rebinds a name with a new let and can change type; mut changes the value without being able to change its type.
Rust has four scalar types: integers (i32 by default), floats (f64 by default), bool, and char.
Integer overflow panics in debug builds and wraps around in release builds.
Tuples group different types and arrays group the same type; both have a fixed size.
The compiler infers types almost all the time; when it cannot decide, as with parse, it requires an explicit annotation.

Sources

The Rust Programming Languagech03-01–ch03-05 · Klabnik, Nichols, Krycho y la comunidad de Rust
The Cargo Booktypes/numeric-types · The Rust Project Developers
Rust by Exampleprimitives
Comprehensive Rustvariable_bindings/basic-syntax · Geisler y colaboradores (Google)

Variables, mutability and types

Same name, different rules

What changes compared with other languages

Split a distance into whole kilometers and leftover meters.

Implement

Split kilometers and meters

Check

Help

Summary

Sources