Declaring Variables with let

Basic let Bindings

The let keyword creates a new variable binding, associating a name with a value. Once assigned, that value can be read anywhere later in the same scope.

Example: Basic let Bindings

fn main() {
    let language = "Rust";
    println!("Learning {}", language);
}

Type Annotations

Although Rust can usually infer a variable's type from its value, you can add an explicit type annotation after a colon. This is required when the type cannot be inferred, and is sometimes used for clarity.

Example: Type Annotations

fn main() {
    let count: i32 = 42;
    println!("count = {}", count);
}

Immutability by Default

Variables created with let are immutable by default, meaning you cannot assign a new value to them after creation. Attempting to do so is a compile error, which is Rust's way of preventing accidental changes.

Note: Try uncommenting a reassignment line for an immutable variable locally -- the compiler error message is very descriptive.

Example: Immutability by Default

fn main() {
    let pi = 3;
    println!("pi is approximately {}", pi);
    // pi = 4; // this line would fail to compile
}

Scope of Variables

A variable is only valid within the block of code (the curly braces) where it was declared. Once that block ends, the variable goes out of scope and can no longer be accessed.

Example: Scope of Variables

fn main() {
    {
        let inner = "only visible here";
        println!("{}", inner);
    }
    println!("Outer scope continues");
}