Destructuring patterns in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a destructuring pattern in Rust?

A destructuring pattern in Rust is a way to break down complex data types like tuples, structs, or enums into their parts, making it easier to access individual values.

beginner

How do you destructure a tuple in Rust?

You use parentheses with variable names matching the tuple's structure. For example: <code>let (x, y) = (1, 2);</code> assigns 1 to x and 2 to y.

beginner

What does the underscore (_) mean in a destructuring pattern?

The underscore (_) is a wildcard that ignores a value in a pattern. It tells Rust you don't care about that part and don't want to bind it to a variable.

intermediate

How can you destructure a struct in Rust?

You use curly braces with field names. For example: <code>let Point { x, y } = point;</code> extracts the x and y fields from the struct named point.

intermediate

What is the benefit of using destructuring patterns in Rust?

Destructuring makes code cleaner and easier to read by directly extracting needed parts of data. It avoids manual indexing or calling getters, reducing errors.

What does this Rust code do?
let (a, b) = (5, 10);

A Causes a syntax error

B Creates a tuple (a, b) with values 5 and 10

C Swaps the values of a and b

D Assigns 5 to a and 10 to b

The code destructures the tuple (5, 10) and assigns 5 to a and 10 to b.

In a pattern, what does the underscore (_) do?

A Binds the value to a variable named _

B Causes a compile error

C Ignores the value without binding

D Duplicates the value

The underscore is a wildcard that ignores the value without creating a variable.

How do you destructure a struct named Point with fields x and y?

A let Point { x, y } = point;

B let Point(x, y) = point;

C let (x, y) = point;

D let {x, y} = point;

Struct destructuring uses curly braces with field names: let Point { x, y } = point;

Which of these is NOT a valid destructuring pattern in Rust?

A let (a, b) = tuple;

B let (x; y) = tuple;

C let Struct { x, y } = s;

D let [x, y] = array;

The semicolon inside parentheses is invalid syntax for destructuring.

Why use destructuring patterns in Rust?

A To directly access parts of data easily

B To slow down the program

C To avoid using variables

D To make code longer and complex

Destructuring helps access parts of data directly, making code cleaner and easier.

Explain how destructuring patterns work in Rust with examples for tuples and structs.

Think about how you can break down data into parts.

Describe the role of the underscore (_) in destructuring patterns and why it is useful.

It's like saying 'I don't care about this part'.

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