DestructuringConcept

Explanation

Destructuring pulls a compound value apart into its components in a single step, binding names directly to the pieces instead of reaching in field-by-field afterward. let Point { x, y } = point; binds x and y directly from a struct; let (width, height) = dimensions(); does the same for a tuple. It's the same pattern syntax used in match arms and if let/while let, just applied at an ordinary let binding, in a function parameter list, or in a for loop variable — anywhere a pattern is legal, not only inside a match.

The appeal is directness: without destructuring, extracting several fields from a struct or tuple means several separate .field or .0 accesses, each one a small chance to typo a name or grab the wrong index. Destructuring states the shape once and gets every piece named correctly in that same step, which reads closer to how the data is actually described elsewhere in the code (a struct definition, a tuple's declared order).

Destructuring composes with the rest of Rust's data model: structs destructure by field name, tuple structs by position, and enum variants by whichever shape they carry — and a pattern can nest arbitrarily, so a struct field that is itself an enum variant can be destructured in the same pattern that destructures the outer struct. .. fills in for "the rest of the fields, which I don't need here," and @ binds a name to a value while also testing it against a sub-pattern, for the rarer case where both the whole value and confirmation of its shape are needed at once.

Because a pattern can fail to match — a tuple destructures unconditionally, but an enum variant might not be the one you assumed — irrefutable destructuring (the kind usable directly in a let) is restricted to patterns that always succeed; anything that might not match belongs in a match arm or an if let/while let instead, which is why those forms share this same pattern syntax rather than inventing a separate one.

Basic usage example

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

let point = Point { x: 3.0, y: 4.0 };
let Point { x, y } = point; // <- destructures the struct into two bindings in one step
println!("{x}, {y}");

let dimensions = (1920, 1080);
let (width, height) = dimensions; // <- destructures the tuple positionally
println!("{width}x{height}");

Best practices & deeper information

struct ServerConfig {
    host: String,
    port: u16,
    max_connections: u32,
    timeout_secs: u32,
}

fn bind_address(config: &ServerConfig) -> String {
    let ServerConfig { host, port, .. } = config; // <- only host and port are needed here
    format!("{host}:{port}")
}

let config = ServerConfig {
    host: "0.0.0.0".to_string(),
    port: 8080,
    max_connections: 100,
    timeout_secs: 30,
};
println!("{}", bind_address(&config));

let scores = vec![("Alice", 92), ("Bob", 87), ("Cara", 95)];

for (name, score) in &scores { // <- destructures each &(&str, i32) tuple as it's produced
    println!("{name}: {score}");
}

struct Customer {
    name: String,
}

enum OrderStatus {
    Placed,
    Shipped { tracking: String },
}

struct Order {
    customer: Customer,
    status: OrderStatus,
}

fn summarize(order: &Order) -> String {
    match order {
        Order { customer: Customer { name }, status: OrderStatus::Shipped { tracking } } => {
            // <- destructures two levels deep: the Customer and the Shipped variant, in one pattern
            format!("{name}'s order shipped, tracking {tracking}")
        }
        Order { customer: Customer { name }, status: OrderStatus::Placed } => {
            format!("{name}'s order is still being prepared")
        }
    }
}