Match expression deep dive in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to match the number 3 and print a message.

Rust

let number = 3;
match number {
    [1] => println!("Three!"),
    _ => println!("Not three"),
}

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

Anumber

B3

C"3"

D4

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes around 3 makes it a string, which won't match the integer.

Using a variable name instead of the literal value.

The match arm must match the value 3 exactly, so use 3.

2fill in blank

medium

Complete the code to match a tuple and print the second element.

Rust

let pair = (5, 10);
match pair {
    ([1], y) => println!("Second is {}", y),
    _ => println!("No match"),
}

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

A_

Bx

C5

Dy

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable for the first element but printing the wrong variable.

Trying to match the exact value 5 instead of ignoring it.

Using _ ignores the first element, so y is the second element printed.

3fill in blank

hard

Fix the error in the match arm to correctly match a reference to a number.

Rust

let num = &7;
match num {
    [1] => println!("Seven!"),
    _ => println!("Not seven"),
}

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

Aref 7

B7

C*7

D&7

Attempts:

3 left

💡 Hint

Common Mistakes

Matching the value 7 directly instead of the reference.

Using *7 which is invalid syntax in patterns.

The variable num is a reference, so the pattern must match &7.

4fill in blank

hard

Fill both blanks to match an enum variant and extract its value.

Rust

enum Color {
    Rgb(u8, u8, u8),
    Cmyk(u8, u8, u8, u8),
}

let color = Color::Rgb(10, 20, 30);
match color {
    Color::[1](r, g, b) => println!("Red: {}, Green: {}, Blue: {}", r, g, b),
    Color::[2](_, _, _, _) => println!("CMYK color"),
}

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

ARgb

BCmyk

CRgbColor

DCmykColor

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect variant names like RgbColor.

Mixing up the order of variants.

The enum variants are Rgb and Cmyk. Use these exact names to match.

5fill in blank

hard

Fill all three blanks to match a struct and extract fields with pattern matching.

Rust

struct Point {
    x: i32,
    y: i32,
}

let p = Point { x: 0, y: 7 };
match p {
    Point { [1]: 0, [2]: [3] } => println!("On the y axis at {}", y),
    _ => println!("Not on the y axis"),
}

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

Ax

By

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping field names or binding the wrong variable.

Using incorrect syntax for struct pattern matching.

Match the field x to 0, bind y to a variable y to print it.

Practice

1. What does the match expression do in Rust?

easy

A. It loops over a range of numbers.

B. It creates a new variable with a fixed value.

C. It defines a function with multiple parameters.

D. It compares a value against multiple patterns and executes matching code.

Solution

1. Step 1: Understand the purpose of match

   The match expression is used to compare a value against several patterns.

2. Step 2: Identify what happens on a match

   When a pattern matches, the corresponding code block runs, making match a clear way to handle multiple cases.

3. Final Answer:

   It compares a value against multiple patterns and executes matching code. -> Option D

4. Quick Check:

   Match expression = pattern matching [OK]

Hint: Match compares values to patterns and runs matching code [OK]

Common Mistakes:

• Thinking match creates variables
• Confusing match with loops
• Assuming match defines functions

2. Which of the following is the correct syntax for a simple match expression in Rust?

easy

A. match value { 1 => println!("One") else println!("Other") }

B. match value { 1 => println!("One"), _ => println!("Other") }

C. match value { 1 -> println!("One"), _ -> println!("Other") }

D. match (value) { 1: println!("One"), _ : println!("Other") }

Solution

1. Step 1: Recall Rust match syntax

   Rust uses curly braces with patterns followed by => and the code to run.

2. Step 2: Check each option

   match value { 1 => println!("One"), _ => println!("Other") } uses correct syntax with => and a default case using _; others use invalid symbols like : or -> or else.

3. Final Answer:

   match value { 1 => println!("One"), _ => println!("Other") } -> Option B

4. Quick Check:

   Correct match syntax uses => and _ for default [OK]

Hint: Use => for patterns and _ for default case in match [OK]

Common Mistakes:

• Using : or -> instead of =>
• Omitting commas between arms
• Using else instead of _ for default

3. What is the output of this Rust code?

let x = Some(5);
match x {
  Some(n) if n > 3 => println!("Greater than 3: {}", n),
  Some(n) => println!("Less or equal to 3: {}", n),
  None => println!("No value"),
}

medium

A. Greater than 3: 5

B. Less or equal to 3: 5

C. No value

D. Compilation error

Solution

1. Step 1: Analyze the match arms and value

   The value is Some(5). The first arm matches Some(n) with a guard n > 3.

2. Step 2: Check the guard condition

   Since 5 > 3 is true, the first arm runs and prints "Greater than 3: 5".

3. Final Answer:

   Greater than 3: 5 -> Option A

4. Quick Check:

   Guard true triggers first arm output [OK]

Hint: Check if guards are true to pick correct match arm [OK]

Common Mistakes:

• Ignoring the if guard condition
• Choosing second arm without checking guard
• Thinking None matches Some value

4. Identify the error in this Rust match expression:

let num = 2;
match num {
  1 => println!("One"),
  2 => println!("Two")
  3 => println!("Three"),
  _ => println!("Other"),
}

medium

A. Match arms must be in parentheses, not braces.

B. Using _ as default case is invalid.

C. Missing comma after the second arm (2 => ...).

D. Cannot match integer values directly.

Solution

1. Step 1: Check syntax of each match arm

   Each arm must end with a comma except possibly the last. The second arm lacks a comma after println!("Two").

2. Step 2: Validate other parts

   Using _ is valid for default, braces are correct, and matching integers is allowed.

3. Final Answer:

   Missing comma after the second arm (2 => ...). -> Option C

4. Quick Check:

   Commas separate match arms [OK]

Hint: Check commas after each match arm carefully [OK]

Common Mistakes:

• Forgetting commas between arms
• Misunderstanding _ as invalid
• Confusing braces with parentheses

5. Given a list of Option<i32> values, how can you use a match expression inside a loop to print only the positive numbers, ignoring None and non-positive values? Choose the correct code snippet.

hard

A. for val in list {
match val {
Some(n) if n > 0 => println!("Positive: {}", n),
_ => (),
}
}

B. for val in list {
match val {
Some(n) => println!("Positive: {}", n),
None => println!("No value"),
}
}

C. for val in list {
if let Some(n) = val {
if n > 0 {
println!("Positive: {}", n);
}
}
}

D. for val in list {
match val {
Some(n) if n <= 0 => println!("Positive: {}", n),
_ => (),
}
}

Solution

1. Step 1: Understand the requirement

   We want to print only positive numbers inside Some, ignoring None and non-positive.

2. Step 2: Analyze each option

   for val in list { match val { Some(n) if n > 0 => println!("Positive: {}", n), _ => (), } } matches Some(n) with guard n > 0 and prints; others ignore with _ => (). for val in list { match val { Some(n) => println!("Positive: {}", n), None => println!("No value"), } } prints all Some values regardless of positivity. for val in list { if let Some(n) = val { if n > 0 { println!("Positive: {}", n); } } } uses if let but is not a match expression. for val in list { match val { Some(n) if n <= 0 => println!("Positive: {}", n), _ => (), } } prints non-positive numbers, opposite of requirement.

3. Final Answer:

   for val in list { match val { Some(n) if n > 0 => println!("Positive: {}", n), _ => (), } } -> Option A

4. Quick Check:

   Match with guard filters positive Some values [OK]

Hint: Use if guards in match to filter values [OK]

Common Mistakes:

• Printing all Some values without checking positivity
• Using if let instead of match when asked
• Reversing guard condition