Destructuring patterns in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this tuple destructuring?

Consider the following Rust code that uses tuple destructuring:

let tuple = (10, 20, 30);
let (a, b, c) = tuple;
println!("{} {} {}", a, b, c);

What will be printed?

Rust

let tuple = (10, 20, 30);
let (a, b, c) = tuple;
println!("{} {} {}", a, b, c);

A 10 30 20

B 30 20 10

C 10 20 30

D Compilation error due to mismatched types

💡 Hint

Remember that tuple destructuring assigns values in order.

The tuple (10, 20, 30) is destructured into variables a, b, and c respectively. So a = 10, b = 20, c = 30.

❓ Predict Output

intermediate

What does this struct destructuring print?

Given this Rust code with a struct and destructuring:

struct Point { x: i32, y: i32 }

let p = Point { x: 5, y: 10 };
let Point { x: a, y: b } = p;
println!("{} {}", a, b);

What is the output?

Rust

struct Point { x: i32, y: i32 }

let p = Point { x: 5, y: 10 };
let Point { x: a, y: b } = p;
println!("{} {}", a, b);

A 5 10

B 10 5

C Compilation error: cannot destructure struct

D 0 0

💡 Hint

Destructuring assigns fields to new variable names.

The struct fields x and y are assigned to variables a and b respectively, so a = 5 and b = 10.

❓ Predict Output

advanced

What is printed by this nested destructuring?

Analyze this Rust code with nested destructuring:

let data = (Some(3), Ok(7));
let (Some(x), Ok(y)) = data;
println!("{} {}", x, y);

What will be printed?

Rust

let data = (Some(3), Ok(7));
let (Some(x), Ok(y)) = data;
println!("{} {}", x, y);

A 3 7

B Some(3) Ok(7)

C Compilation error: cannot destructure enums this way

D Runtime panic due to pattern mismatch

💡 Hint

Remember that pattern matching can destructure enum variants.

The tuple contains Some(3) and Ok(7). The pattern matches and extracts 3 into x and 7 into y.

❓ Predict Output

advanced

What error does this destructuring cause?

Consider this Rust code snippet:

let tuple = (1, 2);
let (a, b, c) = tuple;
println!("{} {} {}", a, b, c);

What error will this code produce?

Rust

let tuple = (1, 2);
let (a, b, c) = tuple;
println!("{} {} {}", a, b, c);

A error: variable c is unused

B error: mismatched tuple size: expected a 3-element tuple but found a 2-element tuple

C prints: 1 2 0

D compiles and prints: 1 2 3

💡 Hint

Check the number of elements in the tuple and pattern.

The pattern expects 3 elements but the tuple has only 2, causing a compile-time error.

🧠 Conceptual

expert

How many variables are bound in this pattern?

Given this Rust pattern:

let (a, (b, c), d) = (1, (2, 3), 4);

How many variables are bound after this destructuring?

Rust

let (a, (b, c), d) = (1, (2, 3), 4);

A 3

B 5

C 2

D 4

💡 Hint

Count each variable name on the left side of the assignment.

The pattern binds variables a, b, c, and d. That is 4 variables total.