Destructuring patterns in Rust - Mini Project: Build & Apply

Destructuring Patterns in Rust

📖 Scenario: You are working on a simple Rust program that manages information about a person. You want to extract parts of the data easily using destructuring patterns.

🎯 Goal: Learn how to use destructuring patterns in Rust to extract values from tuples and structs.

📋 What You'll Learn

Create a tuple with exact values

Create a struct with exact fields and values

Use destructuring patterns to extract values from the tuple and struct

Print the extracted values exactly as instructed

💡 Why This Matters

🌍 Real World

Destructuring patterns help you easily get parts of complex data like user info, coordinates, or settings in real Rust programs.

💼 Career

Many Rust jobs require working with data structures and extracting values cleanly. Destructuring is a common and useful skill.

1

Create a tuple with person data

Create a tuple called person with these exact values: "Alice", 30, and 5.5.

Rust

# Create the tuple called person with the exact values
# Your code here

Hint

Use parentheses to create a tuple: ("Alice", 30, 5.5)

2

Create a struct for person info

Define a struct called Person with fields name (string slice), age (u8), and height (f32). Then create a variable p of type Person with name as "Bob", age as 25, and height as 6.0.

Rust

let person = ("Alice", 30, 5.5);
// Define the struct Person and create variable p with exact values
# Your code here

Hint

Use struct Person { name: &str, age: u8, height: f32 } and then create p with the given values.

3

Destructure the tuple and struct

Use destructuring patterns to extract the values from person into variables name, age, and height. Also destructure p into variables p_name, p_age, and p_height.

Rust

let person = ("Alice", 30, 5.5);
struct Person {
    name: &'static str,
    age: u8,
    height: f32,
}
let p = Person { name: "Bob", age: 25, height: 6.0 };

// Destructure person tuple
// Destructure p struct
# Your code here

Hint

Use let (name, age, height) = person; for the tuple and let Person { name: p_name, age: p_age, height: p_height } = p; for the struct.

4

Print the extracted values

Print the extracted variables exactly as follows, each on its own line:
name
age
height
p_name
p_age
p_height
Use println! macro for printing.

Rust

let person = ("Alice", 30, 5.5);
struct Person {
    name: &'static str,
    age: u8,
    height: f32,
}
let p = Person { name: "Bob", age: 25, height: 6.0 };

let (name, age, height) = person;
let Person { name: p_name, age: p_age, height: p_height } = p;

// Print the variables as instructed
# Your code here

Hint

Use println!("{}", variable); for each variable on its own line.

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