Support

# Pattern match ## Example Execute the following command to run [`./solutions/examples/match.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/pattern_match/solutions/examples/match.rs) ```shell cargo run --example match ``` ## Exercises Exercises are in [`./exercises/src/lib.rs`](https://github.com/Cyfrin/rust-crash-course/blob/main/topics/pattern_match/exercises/src/lib.rs) ### Exercise 1 ```rust pub fn num_to_string(num: u32) -> String { todo!(); } ``` Convert `num` into `String`, `"one"` to `"three"`. Return `"other"` if `num` is greater than 3. ### Exercise 2 ```rust pub fn unwrap_or_default(x: Option<u32>, v: u32) -> u32 { todo!(); } ``` Extract the value wrapped in `Some`. If `x` is `None`, return the default value `v`. ## Test ```shell cargo test ```

Pattern match

Example

Execute the following command to run ./solutions/examples/match.rs

cargo run --example match

Exercises

Exercises are in ./exercises/src/lib.rs

Exercise 1

pub fn num_to_string(num: u32) -> String {

todo!();

}

Convert num into String, "one" to "three".

Return "other" if num is greater than 3.

Exercise 2

pub fn unwrap_or_default(x: Option<u32>, v: u32) -> u32 {

todo!();

}

Extract the value wrapped in Some. If x is None, return the default value v.

Test

cargo test

Match Exercises

An illuminating look at Pattern Match - Discover how Rust's `match` expressions provide elegant and powerful ways to control program flow based on patterns. You'll solidify your understanding by implementing number-to-string conversions and custom logic for `Option` types.

Course Overview

About the course

What you'll learn

Introduction to the Rust programming language

Rust variables and functions

Scalar types, arrays, strings, enum, structs, vectors, and hash maps in Rust

Rust control flows: If / else, if let and let else, loop, match

Rust ownership, including borrow and references

Rust error handling

Rust Modules

Rust Traits

Course Description

Who is this course for?

Smart Contract Developers
Blockchain Engineers
Web3 Developers
Smart Contract Security Researchers
Solutions Architects

Meet your instructors

Tasuku Nakamura

Founder at smartcontract.engineer

Smart contract engineer and educator.

Last updated on July 11, 2025

Thanks for checking us out

Start learning for free

Start for free

Rust Developer

Rust Programming Basics

Section 1: Course Intro

Duration: 6min

Section 2: Rust Intro

Duration: 18min

Section 3: Data Types

Duration: 47min

Section 4: Control Flow

Duration: 15min

1. If Else

An essential guide to Mastering Conditional Logic: Basic `if/else` Statements in Rust - Learn how `if/else` statements form the core of decision-making and program flow in Rust. Discover their power as expressions for concise value assignments, focusing on type consistency and Rust's key syntax rules. Duration: 2min

2. If Else Exercises

A hands-on introduction to If and else statement - Learn to make decisions and control execution paths in Rust using `if` and `else` statements. Solidify your understanding by implementing functions to find the minimum, maximum, and sign of numbers. Reading Time: 0min

3. Loop

An in-depth guide to Rust's Looping Constructs - Command `loop`, `while`, and `for` to orchestrate code repetition, and navigate ranges, arrays, and vectors effectively. Master vector iteration with `into_iter()` (ownership) vs. `iter()` (borrowing), and leverage `loop` expressions to return computed values. Duration: 6min

4. Loop Exercises

A foundational exploration of Loop - Build core programming skills by tackling exercises on finding minimums, maximums, and determining the sign of integers. You'll use conditional logic to implement these fundamental operations, preparing you for more complex iterative algorithms. Reading Time: 0min

5. Match

An essential introduction to Mastering Rust's `match` Control Flow - Discover the power of Rust's `match` expression, a tool for pattern matching that guarantees every case is handled. Learn to use `match` with ranges, enums like `Option` and `Result`, and as an expression that returns a value. Duration: 6min

6. Match Exercises

7. If Let

A concise look at Rust's `if let` for specific pattern matching - Explore how `if let` simplifies your code when you only need to handle one variant of an enum like `Option` or `Result`. This approach avoids the boilerplate of a full `match` statement, leading to cleaner and more direct conditional logic. Duration: 1min

8. If Let Exercises

A targeted guide to using `if let` for `Option` Handling - Learn to effectively use Rust's `if let` statement to conditionally extract values from `Option` types. You'll implement a function that returns the contained value of a `Some` or a specified default for `None`. Reading Time: 0min

Section 5: Ownership

Duration: 19min

Section 6: Error Handling

Duration: 8min

Section 7: Module

Duration: 12min

Section 8: Generic Types And Traits

Duration: 46min

Section 9: Async Await

Duration: 14min