Rust for C-Programmers

21.12 Destructuring Arrays, Slices, Tuples, Structs, Enums, and References

A hallmark of Rust is the ability to destructure all sorts of composite types right in the pattern, extracting and binding only the parts you need. This reduces the need for manual indexing or accessor calls and often leads to more readable code.

21.12.1 Arrays and Slices

fn inspect_array(arr: &[i32]) {
    match arr {
        [] => println!("Empty slice"),
        [first, .., last] => println!("First: {}, Last: {}", first, last),
        [_] => println!("One item only"),
    }
}

fn main() {
    let data = [1, 2, 3, 4, 5];
    inspect_array(&data);
}

A more detailed example:

fn main() {
    let array = [1, -2, 6]; // a 3-element array

    match array {
        [0, second, third] => println!(
            "array[0] = 0, array[1] = {}, array[2] = {}",
            second, third
        ),
        [1, _, third] => println!(
            "array[0] = 1, array[2] = {}, and array[1] was ignored",
            third
        ),
        [-1, second, ..] => println!(
            "array[0] = -1, array[1] = {}, other elements ignored",
            second
        ),
        [3, second, tail @ ..] => println!(
            "array[0] = 3, array[1] = {}, remaining = {:?}",
            second, tail
        ),
        [first, middle @ .., last] => println!(
            "array[0] = {}, middle = {:?}, array[last] = {}",
            first, middle, last
        ),
    }
}

Key Observations:

1. Use _ or .. to skip elements.
2. tail @ .. captures the remaining elements in a slice or array slice.
3. You can combine patterns to handle specific layouts ([3, second, tail @ ..]) or more general ones.

21.12.2 Tuples

fn sum_tuple(pair: (i32, i32)) -> i32 {
    let (a, b) = pair;
    a + b
}

fn main() {
    println!("{}", sum_tuple((10, 20)));
}

21.12.3 Structs

struct User {
    name: String,
    active: bool,
}

fn print_user(user: User) {
    match user {
        User { name, active: true } => println!("{} is active", name),
        User { name, active: false } => println!("{} is inactive", name),
    }
}

fn main() {
    let alice = User {
        name: String::from("Alice"),
        active: true,
    };
    print_user(alice);
}

21.12.4 Enums

Enums often contain data. You can destructure them deeply:

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
}

fn area(shape: Shape) -> f64 {
    match shape {
        Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
        Shape::Rectangle { width, height } => width * height,
    }
}

fn main() {
    let c = Shape::Circle { radius: 3.0 };
    println!("Circle area: {}", area(c));
}

21.12.5 Pattern Matching With References

Rust supports matching references directly:

fn main() {
    // 1) Option of a reference
    let value = Some(&42);
    match value {
        Some(&val) => println!("Got a value by dereferencing: {}", val),
        None => println!("No value found"),
    }

    // 2) Matching a reference using "*reference"
    let reference = &10;
    match *reference {
        10 => println!("The reference points to 10"),
        _ => println!("The reference points to something else"),
    }

    // 3) "ref r"
    let some_value = Some(5);
    match some_value {
        Some(ref r) => println!("Got a reference to the value: {}", r),
        None => println!("No value found"),
    }

    // 4) "ref mut m"
    let mut mutable_value = Some(8);
    match mutable_value {
        Some(ref mut m) => {
            *m += 1;  
            println!("Modified value through mutable reference: {}", m);
        }
        None => println!("No value found"),
    }
}

• Direct Matching (Some(&val)) matches a reference stored in an enum.
• Dereferencing (*reference) manually dereferences in the pattern.
• ref / ref mut borrow the inner value without moving it.