Difference between revisions of "Rust-Programming-Language/C2/Pattern-Matching/English"

Learning Objective

• Pattern matching

Code Files

• The following code file is required to practise this tutorial
• This file is provided in the code files link of this tutorial page

Pattern Matching syntax:

match VALUE {

PATTERN => EXPRESSION,

PATTERN => EXPRESSION,

PATTERN => EXPRESSION,

}

• The match statement is a powerful control flow
• It allows you to compare a value against a series of patterns
• It executes the code based on which pattern matches.
• It is similar to the Switch statement in other languages.

Type the command cargo new pattern

Open the created project.

In the main.rs file, replace the code as shown.

let x = 3;

match x {

1 => println!("One!"),

2 => println!("Two!"),

3 => println!("Three!"),

_ => println!("Something else!"),

}

}

underscore pattern is a catch-all pattern.

It matches any other value not explicitly covered by previous patterns.

In this case, it will print "Something else!", if x is not 1, 2, or 3.

Save the code. Let us execute and see the result.

We can see the output as ‘Three’ which matches the pattern as per the x value.

Let us change the value of x to 10 in the code.

We can see the output as “something else” as expected.

Matching Option and Result type

Option type has:

None → It is used to indicate failure with no value

Some(T) → It returns a value with type T

Result type has:

Ok(T) → It indicates operation succeeded with value T

Err(E) → It indicates operation failed with an error E

Switch back to the Visual Code editor.

fn first_element(array: &[i32]) -> Option<i32> {

if array.len() > 0 {

Some(array[0])

} else {

None

}

}

let array = [];

println!("{:?}", first_element(&array));

}

Here the function first_element, returns the first element of an integer array if it exists.

It takes a reference to an array of integers (&[i32]) as its parameter and returns an Option <i32>.

The function checks the length of the array using array.len().

If the array has one or more elements, it returns Some(array[0]), that is the first element of the array.

If the array is empty, it returns None, indicating that there is no first element to return.

Save the file.

None is displayed as output as the array is empty in the program.

Save the program and run it again.

Now it displays the first element of the array as 10.

fn divide(dividend: i32, divisor: i32) -> Result<i32, String> {

if divisor == 0 {

Err(String::from("Cannot divide by zero"))

} else {

Ok(dividend / divisor)

}

}

let result = divide(10, 2);

match result {

Ok(value) => println!("Result: {}", value),

Err(error) => println!("Error: {}", error),}

The result enum has two variants representing a correct value and an Error.

Here, we define a function divide that performs division.

It returns a Result enum to indicate success or failure.

The divide function takes two parameters: dividend and divisor, both of type i32.

It returns a Result of type <i32.

It can be OK on success that is the result of the division.

Otherwise it returns Err(String) if an error occurs, that is like division by zero.

Save the file.

It displays 5 as the result of the division.

Save the program and run it again.

It displays the error message.

Let us summarize.

• Pattern matching