Destructuring patterns in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to destructure the tuple and print the first value.

Rust

let tuple = (10, 20);
let ([1], _) = tuple;
println!("{}", first);

Drag options to blanks, or click blank then click option'

Ax

Bfirst

Ca

Dval

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name different from the one in println! causes a compile error.

Trying to destructure without parentheses.

The variable first is used to destructure the first element of the tuple.

2fill in blank

medium

Complete the code to destructure the struct and print the name field.

Rust

struct Person { name: String, age: u8 }
let person = Person { name: String::from("Alice"), age: 30 };
let Person { [1], age: _ } = person;
println!("{}", name);

Drag options to blanks, or click blank then click option'

Aname

Bage

Cperson

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using the struct name instead of the field name in the pattern.

Forgetting to ignore the unused field with underscore.

The field name is destructured from the Person struct to access the name.

3fill in blank

hard

Fix the error in the code by completing the pattern to destructure the enum variant.

Rust

enum Message {
    Quit,
    Move { x: i32, y: i32 },
}
let msg = Message::Move { x: 5, y: 10 };
match msg {
    Message::Move [1] => println!("x: {}, y: {}", x, y),
    _ => (),
}

Drag options to blanks, or click blank then click option'

Ax, y

B(x, y)

C{ x, y }

D[x, y]

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses or brackets instead of curly braces for named fields.

Not matching the field names exactly.

The Move variant has named fields, so the pattern must use curly braces with field names.

4fill in blank

hard

Fill both blanks to destructure the nested tuple and print the inner values.

Rust

let nested = ((1, 2), (3, 4));
let ([1], [2]) = nested;
println!("{} {}", a, b);

Drag options to blanks, or click blank then click option'

A(a, b)

Bx

Cy

D(c, d)

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names without parentheses for tuple patterns.

Not matching the nested structure correctly.

The outer tuple is destructured into two inner tuples. The first inner tuple is bound to (a, b), and the second to x (unused here).

5fill in blank

hard

Fill all three blanks to destructure a tuple and filter values greater than 5 in a comprehension.

Rust

let numbers = vec![(1, 6), (3, 4), (7, 8)];
let filtered: Vec<_> = numbers.iter()
    .filter(|&&([1], [2])| [3] > 5)
    .collect();

Drag options to blanks, or click blank then click option'

Ax

By

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable in the filter condition.

Not destructuring the tuple correctly.

The tuple is destructured into x and y. The filter checks if y is greater than 5.

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