The Rust Programming Language — Pattern Matching — Type Parameters

Every coin has two sides — good and bad. Similarly, every programming language does have to deal with something that is defined and undefined or null. Rust particularly does not shine well when it comes to handling undefined or null. Rust will panic and start throwing an error when it comes across something that is undefined or null.

For these edge cases where things do go bad, Rust has given us Type Parameters and twoenum types, Option and Result. These two enum types are built into Rust language and can be used across the language and packages.

Option is used to handle the cases where there are chances or receiving undefined or null.

Result is used to handle the cases where there are chances getting Success and Error, for e.g. an asynchronous task.

Let’s see the definition of Option and Result in the below snippets:

enum Option<T> {
    None,
    Some(T),
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Observations:

1. These enums Options and Result are part of the Rust Language itself.
2. It passes types using T inside the <> brackets, just like generics in TypeScript.
3. This T is known as Type Parameter and can be passed along
4. Option has 2 variants, None and Some<T>. None means undefined/empty/null and Some<T> means some elements of type T.
5. Result has 2 variants, Ok<T> and Err<E>. Ok is for success message and Err is for error message.

Since Option and Result are built in to the system, you do not need the namespace syntax, i.e. ::, for accessing the None or Some and Ok or Error. You can directly use them. Lets have a look at below code snippet:

fn main() {
    let mut my_string: String = "hello world".to_string();
    let mut email_string: String = "[email protected]".to_string();
    // let last_char: char = my_string.pop();
    let last_char: Option<char> = my_string.pop();
    let email: Option<String> = Some(email_string);
    let empty_string: Option<String> = None;
    let success: Result<String, String> = Ok("Success".to_string());
    let error: Result<String, String> = Err("Error".to_string());
}

Observations:

1. Option<char> is used to store the result coming from my_string.pop() which can either be a character or undefined or null if string is empty.
2. Some(email_string) is used to represent some char from email_string
3. Notice that Some is not used as Option::Some(), i.e. with namespace, it is directly used.
4. Similarly Ok and Err are used without a namespace.

Using Type Parameters, we can build a flexible types and prevent Rust compiler from panicking when it encounters undefined and null.

I hope you liked this article about Type Parameters. Please share your feedback in the comments.

You can subscribe to my newsletter about The Rust Programming Language here. You can read about all the articles in this series here.