What are some examples of using Result and Option in Rust?

Can you explain the Result and Option types in Rust with examples?

Sure! In Rust, the Result type is used for functions that can return an error. It has two variants: Ok for success and Err for failure. For example:

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(a / b)
    }
}

The Option type is used for values that can be either something or nothing. It has two variants: Some for a value and None for no value. For example:

fn find_item(items: &[&str], target: &str) -> Option<usize> {
    for (index, &item) in items.iter().enumerate() {
        if item == target {
            return Some(index);
        }
    }
    None
}

Would you like more examples?

Yes, can you give me a practical example of using Option?

Absolutely! Here's a practical example using Option to handle user input:

fn get_username() -> Option<String> {
    let username = std::env::var("USERNAME").ok();
    username
}

fn main() {
    match get_username() {
        Some(name) => println!("Hello, {}!", name),
        None => println!("No username found."),
    }
}

In this example, we try to get the USERNAME from the environment variables. If it exists, we return it wrapped in Some, otherwise, we return None. This way, we can handle the absence of a username gracefully.

That's really helpful! What about using Result in error handling?

Great question! Using Result for error handling allows you to propagate errors easily. Here's an example:

fn read_file_content(file_path: &str) -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string(file_path)?;
    Ok(content)
}

fn main() {
    match read_file_content("example.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

In this example, if reading the file fails, it returns an Err variant, which we can handle in the main function.