Destructuring

🎁 Pattern Matching: Destructuring in Rust

The Gift Box Analogy 🎁

Imagine you receive a gift box. Inside, there are smaller boxes, each containing something special. Destructuring is like opening these boxes and grabbing exactly what you need in one smooth move.

Instead of opening the big box, then opening smaller boxes one by one… you just say:

“Give me the red toy from the left pocket and the blue candy from the right pocket!”

That’s destructuring. One move. Multiple treasures.

🏠 Destructuring Structs

A struct is like a house with labeled rooms. Each room has a name (like kitchen, bedroom) and something inside.

The Story

You have a Person struct:

struct Person {
    name: String,
    age: u32,
}

Instead of doing this:

let person = Person {
    name: String::from("Luna"),
    age: 8,
};
let n = person.name;
let a = person.age;

You can destructure in one step:

let Person { name, age } = person;
println!("{} is {}", name, age);
// Luna is 8

🔑 Key Insight

The field names must match. But you can rename them:

let Person { name: n, age: a } = person;
println!("{} is {}", n, a);

Think of it like:

“Take what’s in the name room and call it n.”

🎨 Destructuring Enums

Enums are like mystery boxes. Each variant is a different surprise inside.

The Story

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    Color(i32, i32, i32),
}

Each variant is different:

• Quit → empty box
• Move → box with x and y coordinates
• Write → box with a message
• Color → box with 3 numbers (RGB)

Opening the Mystery Box

let msg = Message::Move { x: 10, y: 20 };

match msg {
    Message::Quit => {
        println!("Empty box!");
    }
    Message::Move { x, y } => {
        println!("Go to {}, {}", x, y);
    }
    Message::Write(text) => {
        println!("Message: {}", text);
    }
    Message::Color(r, g, b) => {
        println!("RGB: {},{},{}", r, g, b);
    }
}

🔑 Key Insight

Each variant has its own “shape”. You match the shape and grab what’s inside!

🎭 Destructuring Tuples

Tuples are like numbered lockers in a row. No names, just positions.

The Story

let point = (3, 5);

Position 0 has 3. Position 1 has 5.

One-Move Grab

let (x, y) = point;
println!("x={}, y={}", x, y);
// x=3, y=5

With More Items

let data = ("Rust", 2015, true);
let (lang, year, is_cool) = data;
println!("{} born in {}", lang, year);
// Rust born in 2015

🔑 Key Insight

Order matters! First variable gets first value, second gets second, and so on.

🪆 Nested Destructuring

Sometimes gifts come inside other gifts. Like a Russian nesting doll!

The Story

struct Point {
    x: i32,
    y: i32,
}

struct Rectangle {
    top_left: Point,
    bottom_right: Point,
}

A Rectangle contains two Points. Each Point has x and y.

Deep Dive in One Move

let rect = Rectangle {
    top_left: Point { x: 0, y: 10 },
    bottom_right: Point { x: 20, y: 0 },
};

let Rectangle {
    top_left: Point { x: x1, y: y1 },
    bottom_right: Point { x: x2, y: y2 },
} = rect;

println!("({},{}) to ({},{})", x1, y1, x2, y2);
// (0,10) to (20,0)

With Enums Too!

enum Shape {
    Circle { center: (i32, i32), radius: i32 },
}

let s = Shape::Circle {
    center: (5, 5),
    radius: 10,
};

if let Shape::Circle {
    center: (cx, cy),
    radius: r,
} = s {
    println!("Center: ({},{})", cx, cy);
}

🔑 Key Insight

You can go as deep as you need. Just match the structure!

🙈 Ignoring Values in Patterns

Sometimes you don’t need everything. That’s okay! Use special tricks to say “I don’t care about this part.”

The Underscore _

The _ means “throw it away, I don’t need it.”

let point = (10, 20, 30);
let (x, _, z) = point;
println!("x={}, z={}", x, z);
// x=10, z=30

The middle value? Gone. We never stored it.

The Double-Dot ..

When you have many values and only want a few:

struct Config {
    debug: bool,
    verbose: bool,
    timeout: u32,
    retries: u32,
}

let config = Config {
    debug: true,
    verbose: false,
    timeout: 30,
    retries: 3,
};

let Config { debug, .. } = config;
println!("Debug mode: {}", debug);
// Debug mode: true

The .. means “ignore everything else.”

Ignoring Parts of Tuples

let numbers = (1, 2, 3, 4, 5);
let (first, .., last) = numbers;
println!("{} to {}", first, last);
// 1 to 5

Grab first, grab last, skip the middle!

Ignoring with _name

If you need to ignore but avoid warnings:

let (x, _unused, z) = (1, 2, 3);

The _unused is ignored but shows intent.

🔑 Key Insight

• _ = “I don’t care about this one thing”
• .. = “I don’t care about the rest”

🗺️ Visual Summary

graph TD
    A["🎁 Destructuring"] --> B["Structs"]
    A --> C["Enums"]
    A --> D["Tuples"]
    A --> E["Nested"]
    A --> F["Ignoring"]

    B --> B1["let Person{name, age} = p"]
    C --> C1["match on variants"]
    D --> D1["let #40;x, y#41; = point"]
    E --> E1["Go deep into layers"]
    F --> F1["_ and .. patterns"]

🎯 Why This Matters

Destructuring makes your code:

1. Cleaner → Less repetitive access
2. Safer → Compiler checks you got the shape right
3. Expressive → Say exactly what you need

🚀 Quick Reference

💡 Remember

Destructuring is like being a treasure hunter who knows exactly where everything is hidden. Instead of digging around, you reach in and grab precisely what you need.

One pattern. All the treasures. That’s the power of destructuring! 🎁✨