Why pattern matching is needed in Rust - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print a message based on the number using pattern matching.

Rust

let number = 1;
match number {
    [1] => println!("One"),
    2 => println!("Two"),
    _ => println!("Other"),
}

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

A4

B3

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using a number that does not match the variable value.

Forgetting the underscore (_) pattern for other cases.

The pattern 1 matches when number is 1, so the message "One" is printed.

2fill in blank

medium

Complete the code to match a character and print its type.

Rust

let ch = 'a';
match ch {
    [1] => println!("Vowel"),
    'b' | 'c' => println!("Consonant"),
    _ => println!("Other"),
}

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

A'o'

B'a'

C'd'

D'e'

Attempts:

3 left

💡 Hint

Common Mistakes

Using double quotes instead of single quotes for characters.

Choosing a character not listed in the match arms.

The pattern 'a' matches the character ch when it is 'a', printing "Vowel".

3fill in blank

hard

Fix the error in the match pattern to correctly match the tuple.

Rust

let pair = (0, -2);
match pair {
    ([1], y) if y < 0 => println!("Negative y"),
    _ => println!("Other"),
}

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

A0

Bx

C_

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name instead of a literal for the first element.

Not using a guard condition to check if y is negative.

The pattern (0, y) matches when the first element is 0 and binds the second element to y.

4fill in blank

hard

Fill both blanks to create a pattern that matches a Some variant with a positive number.

Rust

let value = Some(5);
match value {
    Some([1]) if [2] > 0 => println!("Positive number"),
    _ => println!("Other"),
}

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

Ax

Cy

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in the pattern and guard.

Using a literal instead of a variable in the pattern.

Using x binds the inner value of Some and checks if it is greater than 0.

5fill in blank

hard

Fill all three blanks to destructure a struct and print its fields.

Rust

struct Point { x: i32, y: i32 }
let p = Point { x: 10, y: 20 };
match p {
    Point { [1]: a, [2]: b } if a < b => println!("x < y"),
    Point { [3]: _, y } => println!("Other case"),
}

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

Ax

By

Dz

Attempts:

3 left

💡 Hint

Common Mistakes

Using a field name that does not exist in the struct.

Using the same variable name for different fields.

The first match arm destructures x and y into a and b. The second arm matches y and ignores x.

Practice

1. Why is pattern matching important in Rust programming?

easy

A. It helps handle different data cases clearly and safely.

B. It makes the program run faster than loops.

C. It automatically fixes syntax errors.

D. It replaces all functions with simpler code.

Solution

1. Step 1: Understand pattern matching purpose

   Pattern matching lets you check different forms of data and handle each case clearly.

2. Step 2: Compare with other options

   The other options describe unrelated or incorrect benefits.

3. Final Answer:

   It helps handle different data cases clearly and safely. -> Option A

4. Quick Check:

   Pattern matching = clear, safe data handling [OK]

Hint: Pattern matching handles many cases clearly and safely [OK]

Common Mistakes:

• Thinking pattern matching speeds up code execution
• Believing it fixes syntax errors automatically
• Confusing pattern matching with function replacement

2. Which of the following is the correct syntax to start a pattern match in Rust?

easy

A. switch(value) { ... }

B. if value == { ... }

C. match value { ... }

D. case value: { ... }

Solution

1. Step 1: Identify Rust pattern matching syntax

   Rust uses the keyword match followed by the value and braces.

2. Step 2: Eliminate other language syntax

   The other options use syntax from other languages or incorrect forms.

3. Final Answer:

   match value { ... } -> Option C

4. Quick Check:

   Rust pattern match starts with 'match' [OK]

Hint: Rust uses 'match' keyword for pattern matching [OK]

Common Mistakes:

• Using 'switch' instead of 'match'
• Trying to use 'case' like in other languages
• Confusing 'if' statement with pattern matching

3. What will this Rust code print?

let number = Some(5);
match number {
    Some(x) if x > 3 => println!("Greater than 3"),
    Some(_) => println!("3 or less"),
    None => println!("No value"),
}

medium

A. 3 or less

B. Greater than 3

C. No value

D. Compilation error

Solution

1. Step 1: Analyze the matched value

   The variable number is Some(5), so it matches Some(x) with x=5.

2. Step 2: Check the guard condition

   The first arm has a condition if x > 3, which is true for 5, so it prints "Greater than 3".

3. Final Answer:

   Greater than 3 -> Option B

4. Quick Check:

   Some(5) with x>3 prints 'Greater than 3' [OK]

Hint: Check guard conditions in match arms carefully [OK]

Common Mistakes:

• Ignoring the if guard and picking second arm
• Thinking None matches Some(5)
• Assuming compilation error due to guard

4. Identify the error in this Rust code using pattern matching:

let value = 10;
match value {
    1 => println!("One"),
    2 => println!("Two"),
}

medium

A. Missing a catch-all pattern to cover other values

B. Incorrect use of println! macro

C. Variable 'value' should be mutable

D. Match arms must return a value

Solution

1. Step 1: Check match arms coverage

   The match only covers 1 and 2, but value is 10, so no arm matches.

2. Step 2: Understand Rust match exhaustiveness

   Rust requires all possible cases covered or a catch-all arm like _.

3. Final Answer:

   Missing a catch-all pattern to cover other values -> Option A

4. Quick Check:

   Match must cover all cases or use catch-all [OK]

Hint: Always include a catch-all (_) arm if not all cases covered [OK]

Common Mistakes:

• Forgetting match must be exhaustive
• Thinking println! usage is wrong
• Assuming variable must be mutable

5. You want to safely extract a number from an Option<i32> and print it, or print "No number" if None. Which pattern matching code correctly does this?

hard

A. match opt {
Some(n) if n > 0 => println!("Number: {}", n),
_ => println!("No number"),
}

B. if let Some(n) = opt {
println!("Number: {}", n);
} else {
println!("No number");
}

C. match opt {
Some => println!("Number: {}", opt),
None => println!("No number"),
}

D. match opt {
Some(n) => println!("Number: {}", n),
None => println!("No number"),
}

Solution

1. Step 1: Check correct pattern matching syntax

   match opt { Some(n) => println!("Number: {}", n), None => println!("No number"), } matches Some(n) and None correctly and prints accordingly.

2. Step 2: Evaluate other options

   The option with a guard condition if n > 0 incorrectly excludes non-positive numbers. The if let approach works but uses destructuring instead of a full match. The option with Some => lacks variable binding and would print the Option rather than the number.

3. Final Answer:

   match opt { Some(n) => println!("Number: {}", n), None => println!("No number"), } -> Option D

4. Quick Check:

   Correct pattern match covers Some and None [OK]

Hint: Match Some(n) and None explicitly for safe extraction [OK]

Common Mistakes:

• Using if let instead of match (not pattern matching)
• Missing variable in Some pattern
• Adding unnecessary conditions excluding valid values