Rust Foundations Practice: Variables, Types & Basic Syntax

const values are inlined by the compiler and don't have a guaranteed memory address. static values live at a fixed location for the entire program.

If you're coming from Python, Rust's variable rules work quite differently. See how Python and Rust handle variables for a side-by-side comparison.

Variables are immutable by default. Add mut when you need to reassign:

// WRONG: let binding is immutable
// let count = 0;
// count += 1;  // error[E0384]

// RIGHT: declare with mut
let mut count = 0;
count += 1;
count += 1;
println!("{count}"); // 2

Shadowing creates an entirely new variable that reuses the name. Unlike mut, shadowing can change the type:

// WRONG: mut cannot change the type
// let mut x = "hello";
// x = x.len();  // error[E0308]: expected &str, found usize

// RIGHT: shadow to change type
let x = "hello";
let x = x.len();  // OK: new variable, type is now usize

// Shadowing chain — each let creates a new variable
let x = 5;
let x = x + 1;   // 6
let x = x * 2;   // 12

In Rust, the last expression in a block (without a semicolon) is its return value. Adding ; turns it into a statement that returns ():

fn add(a: i32, b: i32) -> i32 {
    a + b   // no semicolon → returns i32
}

// WRONG: semicolon makes it return ()
// fn add(a: i32, b: i32) -> i32 {
//     a + b;  // returns () — error[E0308]: expected i32, found ()
// }

This applies everywhere blocks return values — functions, if expressions, match arms, closures.

if is an expression — both branches must return the same type:

// WRONG: branches return different types
// let status = if ready { "ok" } else { 42 };  // error[E0308]

// RIGHT: same type in both branches
let status = if ready { "ok" } else { "wait" };

This also catches the semicolon mistake (function declares -> i32 but returns ()) and type mismatches in match arms. For a deeper look at how match interacts with Rust's type system, see the pattern matching guide.

Scalar Types

Numeric literals support type suffixes and visual separators:

let x = 42;          // i32 (default)
let y = 42u64;       // u64 (suffix)
let z = 1_000_000;   // underscores for readability
let hex = 0xff;      // hexadecimal
let bin = 0b1010;    // binary
let byte = b'A';     // u8

Compound Types

// Tuple: fixed-size, mixed types
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup;         // destructuring
let first = tup.0;           // index access

// Array: fixed-size, same type
let arr: [i32; 5] = [1, 2, 3, 4, 5];
let zeros = [0; 10];         // [0, 0, 0, ..., 0] (10 elements)
let first = arr[0];          // index access (panics on out-of-bounds)

Most common with parse(), because the compiler cannot guess the target type:

// WRONG: what type should "42" parse into?
// let n = "42".parse().unwrap();  // error[E0282]

// RIGHT: annotate the binding
let n: i32 = "42".parse().unwrap();

// RIGHT: turbofish on the method
let n = "42".parse::<i32>().unwrap();

Also required for const and static declarations (type is never inferred):

const MAX: u32 = 100;        // type required
static GREETING: &str = "hi"; // type required

const is evaluated at compile time. It must have a type annotation, uses SCREAMING_SNAKE_CASE, and can never be mut:

const MAX_POINTS: u32 = 100_000;
const PI: f64 = 3.14159;
const GREETING: &str = "hello";

Use const for values fixed across the entire program. Use let for everything else — let bindings are computed at runtime and can depend on function arguments or other variables. Understanding how let and ownership interact is essential; the ownership and borrowing guide covers what happens when you assign or pass values.

Every parameter needs a type annotation. The return type goes after ->:

fn add(a: i32, b: i32) -> i32 {
    a + b  // no semicolon = return value
}

fn greet(name: &str) -> String {
    format!("Hello, {name}!")
}

if, match, and loop are all expressions — they return values:

let status = if is_ready { "ok" } else { "wait" };

let description = match code {
    200 => "ok",
    404 => "not found",
    _ => "unknown",
};

Loops use iterators for for:

for n in [10, 20, 30] {
    println!("{n}");
}

for i in 0..5 {
    println!("{i}");  // 0, 1, 2, 3, 4
}

let mut count = 0;
while count < 3 {
    count += 1;
}

Once you move beyond scalar types, structs and enums let you define custom compound types that the compiler checks just as rigorously.

Unused Variables: the _ Prefix

Rust warns about unused variables. Prefix with _ to silence the warning:

let _unused = compute_something();  // no warning
let _ = risky_op();                 // discard result (no binding at all)

• The Rust Book: Common Programming Concepts — variables, types, functions, control flow
• The Rust Book: Data Types — scalars, tuples, arrays
• Rust Reference: Items and Expressions — const, static, expression semantics