**Course Title:** Mastering Rust: From Basics to Systems Programming **Section Title:** Error Handling and Result Types **Topic:** Develop a Rust application that handles errors using Result and Option types. **Lab Overview:** In this lab, you'll learn how to develop a Rust application that effectively handles errors using the `Result` and `Option` types. You'll explore how to use these types to handle errors in a real-world scenario, creating a robust and maintainable application. **Step 1: Understanding the Problem Domain** Before diving into error handling, let's define the problem domain. Imagine you're building a simple calculator application that takes in mathematical expressions as input and evaluates them. However, you want to ensure that your application can handle invalid inputs, such as division by zero or unknown operators. **Step 2: Defining the Calculator Function** Create a new Rust file called `calculator.rs` and define a `calc` function that takes in a mathematical expression as a string. This function will return a `Result` type, where the `Ok` variant represents a successful calculation and the `Err` variant represents an error. ```rust // calculator.rs use std::num::ParseFloatError; fn calc(expression: &str) -> Result<f64, String> { let (operand1, operator, operand2) = parse_expression(expression)?; match operator { '+' => Ok(operand1 + operand2), '-' => Ok(operand1 - operand2), '*' => Ok(operand1 * operand2), '/' => { if operand2 == 0.0 { Err("Cannot divide by zero".to_string()) } else { Ok(operand1 / operand2) } } _ => Err("Unknown operator".to_string()), } } fn parse_expression(expression: &str) -> Result<(f64, char, f64), String> { let mut parts = expression.split_whitespace(); let operand1_str = parts.next().ok_or("Invalid expression")?; let operand1 = operand1_str.parse::<f64>().map_err(|e| e.to_string())?; let operator = parts.next().ok_or("Invalid expression")?.chars().next().unwrap(); let operand2_str = parts.next().ok_or("Invalid expression")?; let operand2 = operand2_str.parse::<f64>().map_err(|e| e.to_string())?; Ok((operand1, operator, operand2)) } ``` **Step 3: Handling Errors using Result** In the `calc` function, you've already handled errors using the `Result` type. Now, let's create a `main` function that calls `calc` and handles any errors that may occur. ```rust // main.rs mod calculator; fn main() { let expression = "10 + 5"; match calculator::calc(expression) { Ok(result) => println!("Result: {}", result), Err(error) => println!("Error: {}", error), } } ``` **Step 4: Handling Optional Values using Option** In addition to error handling, Rust's `Option` type is useful for handling optional values. Create a new function called `get_operand` that returns an `Option` type representing an operand. ```rust // calculator.rs fn get_operand(expression: &str) -> Option<f64> { expression.parse::<f64>().ok() } ``` **Step 5: Using Option to Simplify Error Handling** Now, you can use the `Option` type to simplify error handling in your `calc` function. Instead of manually handling errors for each operand, you can use the `?` operator to automatically convert `None` to an error. ```rust // calculator.rs fn calc(expression: &str) -> Result<f64, String> { let (operand1, operator, operand2) = parse_expression(expression)?; let operand1 = operand1.ok_or("Invalid operand")?; let operand2 = operand2.ok_or("Invalid operand")?; // ... } ``` **Conclusion:** In this lab, you've developed a Rust application that effectively handles errors using the `Result` and `Option` types. You've learned how to define error-handling functions, handle errors using `Result`, and simplify error handling using `Option`. Practice using these types to create robust and maintainable applications. **Additional Resources:** * [The Rust Programming Language: Error Handling](https://doc.rust-lang.org/book/error-handling.html) * [The Rust Programming Language: Option and Result](https://doc.rust-lang.org/book/option-result.html) * [Rust By Example: Option and Result](https://doc.rust-lang.org/rust-by-example/custom_types/options.html) **Leave a comment or ask for help:** If you have any questions or need further clarification on any of the concepts covered in this lab, feel free to leave a comment below.