Rust Interview Questions

The Option type in Rust is a powerful and commonly used enum that represents an optional value. It encapsulates a value that may or may not be present, providing a type-safe way to handle cases where a value is either present (Some) or absent (None). This eliminates the need for null pointers and helps prevent common errors related to uninitialized or missing values.

Definition

The Option enum is defined in the standard library as follows:

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

Usage

Creating an Option

You can create an Option value using Some to represent a value that is present, and None to represent the absence of a value.

fn main() {
    let some_number = Some(5);
    let some_string = Some("Hello");

    let absent_number: Option<i32> = None;
}

Unwrapping an Option

To access the value inside an Option, you can use pattern matching or the unwrap method. However, using unwrap is generally discouraged unless you are certain that the Option is Some, as it will panic if called on a None.

fn main() {
    let some_number = Some(5);

    match some_number {
        Some(value) => println!("The value is: {}", value),
        None => println!("No value"),
    }

    // Using unwrap (will panic if the Option is None)
    let number = some_number.unwrap();
    println!("Unwrapped value: {}", number);
}

Safe Unwrapping with unwrap_or, unwrap_or_else, and unwrap_or_default

To provide a default value when unwrapping an Option, you can use methods like unwrap_or, unwrap_or_else, and unwrap_or_default.

fn main() {
    let some_number = Some(5);
    let no_number: Option<i32> = None;

    println!("Value is: {}", some_number.unwrap_or(0));
    println!("Value is: {}", no_number.unwrap_or(0));

    // Using unwrap_or_else to provide a default value with a function
    println!("Value is: {}", no_number.unwrap_or_else(|| 42));

    // Using unwrap_or_default (requires Option<T> where T: Default)
    let no_string: Option<String> = None;
    println!("Value is: {}", no_string.unwrap_or_default());
}

Using map and and_then

To transform an Option or chain computations, you can use map and and_then.

fn main() {
    let some_number = Some(5);

    // Using map to transform the value inside Option
    let plus_one = some_number.map(|x| x + 1);
    println!("Plus one: {:?}", plus_one);

    // Using and_then to chain computations that return an Option
    let square_then_to_string = some_number
        .map(|x| x * x)
        .and_then(|x| Some(x.to_string()));
    println!("Square then to string: {:?}", square_then_to_string);
}

Practical Example

Here is a practical example demonstrating the use of Option to handle the possibility of a missing configuration value:

fn get_config_value(key: &str) -> Option<String> {
    let config = std::collections::HashMap::from([
        ("database_url", "postgres://localhost".to_string()),
        ("api_key", "12345".to_string()),
    ]);

    config.get(key).cloned()
}

fn main() {
    let database_url = get_config_value("database_url").unwrap_or_else(|| "localhost".to_string());
    println!("Database URL: {}", database_url);

    let unknown_key = get_config_value("unknown_key").unwrap_or("default_value".to_string());
    println!("Unknown key: {}", unknown_key);
}

Summary

• Definition: Option is an enum that can be Some(T) for a present value or None for no value.
• Creating: Use Some(value) for a present value and None for no value.
• Unwrapping: Use pattern matching or methods like unwrap, unwrap_or, unwrap_or_else, and unwrap_or_default.
• Transforming: Use map and and_then for transformations and chaining operations.

The Option type provides a safe and expressive way to handle optional values in Rust, preventing many common errors related to missing or null values.