Common Programming Concepts in Rust

Rust combines low-level systems control with high-level ergonomic guarantees. Mastering the language requires understanding how it handles memory safety, type inference, and immutability by default at the syntax level. This chapter covers the foundational building blocks of Rust programs: variable bindings, scalar and compound data types, the expression-based nature of functions, and fine-grained control flow.

1. Variables and Immutability

In Rust, variables are immutable by default. This design decision enforces concurrency safety and prevents unexpected state mutations across different parts of a program.

The Problem with Uncontrolled Mutation

In many systems languages, variables are mutable unless marked otherwise. This often leads to subtle bugs where data is altered concurrently or modified out of order:

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
    x = 6; // Compile-time error
    println!("The value of x is: {}", x);
}

Attempting to compile this code results in an immediate compiler error:

Explicit Mutability with mut

To allow a variable to change value, Rust requires explicit intent via the mut keyword:

fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

Output:
The value of x is: 5
The value of x is: 6

2. Constants vs. Variables

Constants are values bound to an identifier that can never be altered under any circumstance. Although immutable variables and constants appear similar, they serve fundamentally different architectural roles.

const SUBSCRIBER_COUNT: u32 = 100_000;

Key Differences Between let and const

Note on Numeric Readability: Rust allows underscores (_) inside numeric literals as visual separators. Setting 100_000 evaluates identically to 100000, significantly improving legibility.

3. Variable Shadowing

Rust allows you to declare a new variable with the same name as a previous variable. The second variable shadows the first, meaning the compiler resolves the identifier to the newly declared variable until the scope ends or it is shadowed again.

fn main() {
    let x = 5;
    let x = x + 1; // Shadows the first x
    {
        let x = x * 2; // Shadows x within inner scope
        println!("Inner scope value: {}", x); // Prints 12
    }
    println!("Outer scope value: {}", x); // Prints 6
}

Shadowing vs. Reassignment (mut)

1. Preserving Immutability: By using let, you transform a value through intermediate steps while ensuring the variable remains safely immutable after each declaration.
2. Type Mutation: Shadowing allows you to change the underlying type of a variable name without inventing distinct identifiers (e.g., spaces_str vs spaces_num).

// Valid: Shadowing allows type change
let x = "six";        // &str
let x = x.len();      // usize

// Illegal: Mutable variable cannot change its underlying type
let mut y = 5;        // i32
y = "six";            // Compile-time mismatched types error

4. Scalar Data Types

A scalar type represents a single value. Rust contains four primary scalar categories: integers, floating-point numbers, booleans, and characters.

1. Integers

Integers are whole numbers without a fractional component. They are categorized by bit width and signedness:

2. Floating-Point Types

Rust provides two primitive floating-point types IEEE-754:

• f32: Single-precision float (32 bits).
• f64: Double-precision float (64 bits, default due to modern hardware speed and greater precision).

3. Boolean Type

Represented by the bool keyword, taking values true or false (1 byte in size).

4. Character Type

Declared with single quotes ('a'), the char type is 4 bytes in size and represents a Unicode Scalar Value. It supports accented characters, Chinese/Japanese/Korean glyphs, emoji, and zero-width spaces.

5. Integer Representation and Overflow Behavior

Rust allows integer literals across various bases:

let decimal = 98_222;
let hex = 0xff;
let octal = 0o77;
let binary = 0b1111_0000;
let byte_literal = b'A'; // u8 only

The Mechanics of Integer Overflow

Consider an 8-bit unsigned integer (u8), which can hold values from $0$ to $255$. Setting or incrementing this variable to $256$ triggers an integer overflow. Rust handles this depending on compilation flags:

Warning: Relying on overflow wrapping is considered an anti-pattern. If wrapping is explicitly required, developers should use standard library wrapping methods such as wrapping_add.

6. Compound Data Types: Tuples and Arrays

Compound types aggregate multiple values into a single unified type. Rust provides two primitive compound types: tuples and arrays.

The Tuple Type

A tuple groups multiple values with different types into one fixed-size container.

fn main() {
    let sub_record: (&str, u32) = ("Let's Get Rusty", 100_000);

    // Extraction Method 1: Pattern Matching / Destructuring
    let (channel, sub_count) = sub_record;
    println!("Channel: {}, Subs: {}", channel, sub_count);

    // Extraction Method 2: Direct Period (.) Index Access
    let count = sub_record.1;
    println!("Sub count via index: {}", count);
}

The Array Type

Unlike a tuple, every element in an array must have the exact same type. Furthermore, arrays in Rust have a fixed length known at compile-time (unlike dynamically resizable vectors).

// Explicit type signature: [element_type; length]
let numbers: [i32; 5] = [1, 2, 3, 4, 5];

// Initialize array with identical elements: [value; repetitions]
let zeros = [0; 8]; // Equivalent to [0, 0, 0, 0, 0, 0, 0, 0]

// Indexing elements
let first = numbers[0];

Memory Safety: Out-of-Bounds Checks

fn main() {
    let a = [1, 2, 3];
    let index = 4;
    let element = a[index]; // Compiles, but will panic
}

When accessing an array via an index, Rust validates that the runtime index is strictly less than the length:

In low-level languages like C/C++, invalid index access allows reading or modifying arbitrary memory addresses (buffer overflow). Rust completely protects memory integrity by halting execution immediately.

7. Functions, Parameters, and Signatures

Functions are declared using the fn keyword. Rust follows the snake_case naming convention for all function identifiers and files.

fn main() {
    println!("Main execution start.");
    print_labeled_measurement(5, "hours");
}

fn print_labeled_measurement(value: i32, unit_label: &str) {
    println!("The measurement is: {} {}", value, unit_label);
}

Strict Type Signatures

In function signatures, every parameter must have an explicit type annotation. The compiler intentionally avoids type inference in function headers to ensure signatures act as explicit contracts throughout the codebase.

8. Statements vs. Expressions Architecture

Rust is an expression-based language. Distinguishing between statements and expressions is critical to understanding control flow and function returns.

• Statements: Instructions that perform an action and do not return a value. They terminate with a semicolon.
• Expressions: Evaluate to a resulting value. They do not include a trailing semicolon when used as returns.

let y = 6; // Statement (does not return a value)
// let x = (let y = 6); // INVALID: Statements return nothing (())

A block ({ ... }) is itself an expression that evaluates to its final expression:

let y = {
    let x = 3;
    x + 1 // No semicolon: This expression is returned to y
};
// y evaluates to 4

Function Return Values

Functions return the value of the final expression evaluated in their body implicitly. Alternatively, the return keyword can be used to exit early.

// Method 1: Idiomatic implicit return (last line expression without semicolon)
fn add(x: i32, y: i32) -> i32 {
    x + y
}

// Method 2: Explicit return keyword
fn add_explicit(x: i32, y: i32) -> i32 {
    return x + y;
}

Common Pitfall: Placing a semicolon at the end of the line x + y; converts the expression into a statement, causing it to return the unit type () instead of i32, which triggers a compiler mismatch error.

9. Control Flow: Conditional Branching (if Expressions)

Branching paths allow execution based on conditions. The condition must strictly evaluate to a bool.

fn main() {
    let number = 7;

    if number < 5 {
        println!("Condition evaluated true");
    } else if number == 7 {
        println!("Number is exactly seven");
    } else {
        println!("Condition evaluated false");
    }
}

Non-Boolean Guard: Unlike JavaScript, Python, or C, Rust will not automatically convert non-boolean types into truthy or falsy values. Writing if number { ... } generates an explicit compile-time type mismatch error.

Using if in a let Statement

Because if is an expression, its result can be bound directly to a variable:

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    
    println!("Assigned: {}", number);
}

Both arms must evaluate to the same type. If the if arm yields an integer and the else arm yields a string, the compiler rejects the code at compile-time.

10. Looping Mechanisms: loop, while, and for

Rust provides three built-in loop abstractions designed for distinct runtime workflows.

1. loop (Infinite Execution & Value Returns)

The loop keyword signals the compiler to repeat a block indefinitely until an explicit break condition is met. You can pass a value to break to return it directly from the loop expression:

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Returns 20 to result variable
        }
    };

    println!("Result: {}", result);
}

2. while (Conditional Looping)

Runs as long as an evaluation condition holds true:

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }

    println!("LIFTOFF!");
}

3. for (Collection Traversal and Ranges)

The for loop is the most idiomatic and secure loop in Rust. It eliminates manual index tracking, removing bounds-checking overhead and preventing off-by-one errors.

fn main() {
    let a = [10, 20, 30, 40, 50];

    // Iterating over collections
    for element in a.iter() {
        println!("Value: {}", element);
    }

    // Iterating over numeric ranges (1..4 is right-exclusive: 1, 2, 3)
    for number in 1..4 {
        println!("Count: {}", number);
    }
}

Loop Type Comparison

11. Code Documentation: Comments

Rust supports single-line, multi-line, and documentation comments:

// Single-line comment explaining why logic exists

/*
   Multi-line block comment
   spanning multiple execution regions
*/

/// Triple-slash documentation comments (supports Markdown syntax)
/// Used by rustdoc to generate project documentation.

Summary and Key Takeaways

• Immutability by Default: Variables cannot change unless explicitly marked with the mut keyword, promoting safe programming practices.
• Constants Are Compile-Time Constructs: Declared via const, they cannot use mut, must have an explicit type annotation, and can only be set to compile-time evaluatable expressions.
• Shadowing Enables Type Transformation: Re-declaring a variable name with let allows you to change its value and type while preserving immutability for the rest of its scope.
• Scalars vs. Compounds: Scalars hold singular values (integers, floats, booleans, characters); compounds group data (heterogeneous fixed-size tuples, homogeneous fixed-size arrays).
• Safe Bounds Checking: Out-of-bounds array access is caught at runtime, triggering an immediate panic to prevent memory vulnerabilities.
• Expressions vs. Statements: Statements execute actions without returning values (ending in ;); expressions evaluate to values and are returned implicitly if they are the final line of a block.
• Strict Conditional Expressions: Conditions in if checks must strictly evaluate to bool. Because if is an expression, it can be assigned directly to variables using let.
• Idiomatic Looping: While loop allows infinite execution and returns values via break, for loops combined with iterators or ranges (1..4) are the most idiomatic and safe way to iterate in Rust.