Match overview in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

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

Rust

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

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

A0

B3

C4

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using a value that does not match the variable.

Forgetting to cover all cases with a wildcard.

The match arm for 1 matches the number 1 and prints "One".

2fill in blank

medium

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

Rust

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

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

A'e'

B'a'

C'd'

D'f'

Attempts:

3 left

💡 Hint

Common Mistakes

Using double quotes instead of single quotes for characters.

Matching a character not covered in the arms.

The match arm for 'a' matches the vowel character and prints "Vowel".

3fill in blank

hard

Fix the error in the match expression to correctly handle the boolean value.

Rust

let flag = true;
match flag {
    [1] => println!("True"),
    false => println!("False"),
}

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

Atrue

BTrue

C"true"

DTRUE

Attempts:

3 left

💡 Hint

Common Mistakes

Using uppercase or quoted booleans.

Using a string instead of a boolean.

Boolean values in Rust are lowercase true and false.

4fill in blank

hard

Fill both blanks to match a tuple and print the correct message.

Rust

let pair = (0, -2);
match pair {
    ([1], [2]) => println!("Matched zero and negative number"),
    _ => println!("No match"),
}

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

A0

B1

C-2

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the tuple elements.

Using positive numbers instead of negative.

The tuple (0, -2) matches the pattern with first element 0 and second element -2.

5fill in blank

hard

Fill all three blanks to match an enum and print the correct message.

Rust

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

let dir = Direction::Left;
match dir {
    Direction::[1] => println!("Going up"),
    Direction::[2] => println!("Going down"),
    Direction::[3] => println!("Going left"),
    _ => println!("Other direction"),
}

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

AUp

BDown

CLeft

DRight

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase variant names.

Mixing up the order of variants.

The match arms correspond to the enum variants Up, Down, and Left.

Practice

1. What is the main purpose of the match statement in Rust?

easy

A. To check a value against multiple patterns clearly and concisely

B. To create loops that run a fixed number of times

C. To define new data types

D. To handle errors using exceptions

Solution

1. Step 1: Understand the role of match

   The match statement compares a value against many patterns, making code clearer than many if-else statements.

2. Step 2: Compare with other options

   Loops run repeatedly, data types define structures, and exceptions handle errors, but match is for pattern matching.

3. Final Answer:

   To check a value against multiple patterns clearly and concisely -> Option A

4. Quick Check:

   Match = pattern checking [OK]

Hint: Match replaces many if-else with clear pattern checks [OK]

Common Mistakes:

• Confusing match with loops
• Thinking match defines types
• Assuming match handles exceptions

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

easy

A. match value { pattern1 => expr1, pattern2 => expr2, _ => default_expr }

B. match (value) { pattern1: expr1; pattern2: expr2; default: default_expr }

C. match value { pattern1 -> expr1, pattern2 -> expr2, _ -> default_expr }

D. match value { pattern1 => expr1; pattern2 => expr2; _ => default_expr }

Solution

1. Step 1: Recall Rust match syntax

   Rust uses curly braces with patterns followed by => and expressions separated by commas.

2. Step 2: Check each option

   match value { pattern1 => expr1, pattern2 => expr2, _ => default_expr } uses correct braces, arrows, and commas. Options B and D use semicolons incorrectly. match value { pattern1 -> expr1, pattern2 -> expr2, _ -> default_expr } uses -> instead of =>.

3. Final Answer:

   match value { pattern1 => expr1, pattern2 => expr2, _ => default_expr } -> Option A

4. Quick Check:

   Correct match syntax uses => and commas [OK]

Hint: Use => between pattern and expression, separate arms with commas [OK]

Common Mistakes:

• Using semicolons instead of commas
• Using -> instead of =>
• Missing the catch-all _ pattern

3. What will be the output of this Rust code?

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

medium

A. One

B. Two

C. Other

D. Three

Solution

1. Step 1: Identify the matched value

   The variable number is 3, so the match will look for pattern 3.

2. Step 2: Find the matching arm

   The arm 3 => println!("Three") matches and prints "Three".

3. Final Answer:

   Three -> Option D

4. Quick Check:

   number=3 matches 3 => "Three" [OK]

Hint: Match value exactly to print correct output [OK]

Common Mistakes:

• Choosing default _ arm instead of exact match
• Confusing numbers with strings
• Ignoring the value of number

4. Identify the error in this Rust match code snippet:

let x = 5;
match x {
    1 => println!("One"),
    2 => println!("Two"),
    3 => println!("Three")
}

medium

A. Missing semicolon after println! macros

B. Using parentheses instead of curly braces in match

C. Missing catch-all _ pattern to handle other values

D. Incorrect variable declaration

Solution

1. Step 1: Check match arms completeness

   The match covers 1, 2, and 3 but does not handle other values like 5.

2. Step 2: Understand Rust match requirements

   Rust requires all possible values to be covered, usually by a catch-all _ pattern.

3. Final Answer:

   Missing catch-all _ pattern to handle other values -> Option C

4. Quick Check:

   Always include _ to cover unmatched cases [OK]

Hint: Always add _ arm to handle unexpected values [OK]

Common Mistakes:

• Forgetting the catch-all _ pattern
• Thinking semicolons are mandatory after println!
• Confusing braces with parentheses

5. Given this Rust code, what will be the output?

let grade = 'B';
match grade {
    'A' | 'B' | 'C' => println!("Pass"),
    'D' => println!("Conditional Pass"),
    _ => println!("Fail"),
}

hard

A. Conditional Pass

B. Pass

C. Fail

D. Compilation error

Solution

1. Step 1: Identify the value and patterns

   The variable grade is 'B'. The first arm matches 'A', 'B', or 'C'.

2. Step 2: Determine which arm runs

   Since 'B' matches the first arm, it prints "Pass".

3. Final Answer:

   Pass -> Option B

4. Quick Check:

   Multiple patterns with | match 'B' => "Pass" [OK]

Hint: Use | to match multiple patterns in one arm [OK]

Common Mistakes:

• Assuming only single pattern per arm
• Choosing wrong output for 'B'
• Thinking code causes compilation error