Destructuring patterns in Rust - Step-by-Step Execution

Concept Flow - Destructuring patterns

Start with a value

↓

Apply destructuring pattern

↓

Extract parts into variables

↓

Use extracted variables

↓

End

Destructuring patterns break a value into parts and assign them to variables step-by-step.

Execution Sample

Rust

let (x, y) = (10, 20);
println!("x = {}, y = {}", x, y);

This code splits a tuple into two variables x and y, then prints them.

Execution Table

Step	Action	Pattern	Value	Variables Assigned
1	Start with tuple value	(x, y)	(10, 20)	none
2	Match pattern to value	(x, y)	(10, 20)	x = 10, y = unassigned
3	Assign y from tuple	(x, y)	(10, 20)	x = 10, y = 20
4	Use variables	N/A	N/A	Print x=10, y=20
5	End	N/A	N/A	Variables x=10, y=20 in scope

💡 All parts of the tuple matched and assigned, execution ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
x	unassigned	10	10	10
y	unassigned	unassigned	20	20

Key Moments - 2 Insights

Why is y unassigned after step 2 but assigned after step 3?

Step 2 starts matching the pattern but only assigns x first; y is assigned in step 3 as the pattern matches the second tuple element (see execution_table rows 2 and 3).

What happens if the pattern and value lengths don't match?

Rust will give a compile-time error because the destructuring pattern must match the value structure exactly (not shown here but important to know).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after step 3?

A 10

B 20

C unassigned

D None

💡 Hint

Check the 'Variables Assigned' column in row 3 of the execution_table.

At which step are both x and y assigned values?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look at the 'Variables Assigned' column to see when both variables have values.

If the tuple was (10, 20, 30), what would happen to the destructuring pattern (x, y)?

A x=10, y=20, 30 ignored

B x=10, y=30

C Compile-time error due to mismatch

D x=20, y=30

💡 Hint

Rust requires pattern and value to match exactly; extra elements cause errors.

Concept Snapshot

Destructuring patterns let you split complex values into parts.
Syntax: let (a, b) = (1, 2);
Each pattern part matches a value part.
All parts must match exactly.
Variables get assigned in order.
Use destructuring to simplify code.

Full Transcript

This visual trace shows how destructuring patterns work in Rust. We start with a tuple (10, 20). The pattern (x, y) matches this tuple. Step 2 assigns x to 10, step 3 assigns y to 20. After both assignments, we can use x and y as separate variables. If the pattern and value don't match in size, Rust will give an error. This helps break down values simply and safely.

Practice

1. What does destructuring a tuple in Rust allow you to do?

easy

A. Change the tuple's type

B. Convert the tuple into a string

C. Break the tuple into individual variables easily

D. Sort the elements inside the tuple

Solution

1. Step 1: Understand tuple structure

   A tuple groups multiple values together as one compound value.

2. Step 2: Apply destructuring

   Destructuring lets you assign each element of the tuple to its own variable easily.

3. Final Answer:

   Break the tuple into individual variables easily -> Option C

4. Quick Check:

   Destructuring = Break tuple into variables [OK]

Hint: Destructuring splits compound data into parts fast [OK]

Common Mistakes:

• Thinking destructuring changes data type
• Confusing destructuring with conversion
• Assuming destructuring sorts data

2. Which of the following is the correct syntax to destructure a tuple (x, y) into variables a and b in Rust?

easy

A. let (a, b) = (x, y);

B. let [a, b] = (x, y);

C. let {a, b} = (x, y);

D. let a, b = (x, y);

Solution

1. Step 1: Recall tuple destructuring syntax

   Rust uses parentheses to destructure tuples, matching the tuple structure.

2. Step 2: Match variables to tuple elements

   Using let (a, b) = (x, y); correctly assigns a to x and b to y.

3. Final Answer:

   let (a, b) = (x, y); -> Option A

4. Quick Check:

   Tuple destructuring uses parentheses [OK]

Hint: Use parentheses to destructure tuples in let statements [OK]

Common Mistakes:

• Using square brackets instead of parentheses
• Using curly braces for tuples
• Trying to assign without parentheses

3. What will be the output of this Rust code?

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

medium

A. x = 3, y = 7

B. x = 7, y = 3

C. x = (3, 7), y = (3, 7)

D. Compilation error

Solution

1. Step 1: Destructure tuple values

   The tuple point has values (3, 7). Destructuring assigns x = 3 and y = 7.

2. Step 2: Print the variables

   The println! macro outputs the values of x and y in order.

3. Final Answer:

   x = 3, y = 7 -> Option A

4. Quick Check:

   Destructured values print as assigned [OK]

Hint: Destructure tuple to variables, then print them [OK]

Common Mistakes:

• Swapping values in destructuring
• Printing the whole tuple instead of variables
• Expecting syntax error due to destructuring

4. Identify the error in this Rust code snippet:

let (a, b) = (1, 2, 3);

medium

A. Missing semicolon at the end

B. Variables a and b are not mutable

C. Tuple syntax is incorrect

D. Too many values to destructure into two variables

Solution

1. Step 1: Check tuple length vs variables

   The tuple has 3 values but only 2 variables are provided for destructuring.

2. Step 2: Understand destructuring rules

   Rust requires the number of variables to match the tuple elements exactly.

3. Final Answer:

   Too many values to destructure into two variables -> Option D

4. Quick Check:

   Variable count must match tuple length [OK]

Hint: Match variable count to tuple elements exactly [OK]

Common Mistakes:

• Ignoring tuple length mismatch
• Assuming Rust auto-fills missing variables
• Thinking mutability causes error here

5. Given the enum and code below, what is the value of result?

enum Shape {
    Circle(f64),
    Rectangle { width: f64, height: f64 },
}

let shape = Shape::Rectangle { width: 3.0, height: 4.0 };
let result = match shape {
    Shape::Circle(radius) => radius * radius * 3.14,
    Shape::Rectangle { width, height } => width * height,
};

hard

A. 37.68

B. 12.0

C. 7.0

D. Compilation error

Solution

1. Step 1: Identify the variant matched

   The variable shape is a Rectangle with width 3.0 and height 4.0.

2. Step 2: Calculate area using destructured values

   The match arm for Rectangle multiplies width and height: 3.0 * 4.0 = 12.0.

3. Final Answer:

   12.0 -> Option B

4. Quick Check:

   Rectangle area = width * height = 12.0 [OK]

Hint: Match enum variant and destructure fields to compute result [OK]

Common Mistakes:

• Confusing Circle and Rectangle variants
• Using radius formula for Rectangle
• Forgetting to destructure fields properly