The Result
enum is a fundamental error handling mechanism in Rust. It represents the outcome of an operation that can either succeed or fail.
The Result
enum is defined as follows:
enum Result<T, E> {
Ok(T),
Err(E),
}
It has two variants:
Ok(T)
: Represents a successful operation, containing a value of type T.Err(E)
: Represents a failed operation, containing an error of type E.Here's a simple example demonstrating how to use the Result
enum:
fn divide(x: f64, y: f64) -> Result<f64, String> {
if y == 0.0 {
Err("Division by zero".to_string())
} else {
Ok(x / y)
}
}
fn main() {
match divide(10.0, 2.0) {
Ok(result) => println!("Result: {}", result),
Err(error) => println!("Error: {}", error),
}
}
In this example, the divide
function returns a Result
that can either be an Ok
value containing the division result or an Err
value with an error message.
Rust provides several methods for working with Result
values:
Use pattern matching to handle both success and failure cases:
match result {
Ok(value) => println!("Success: {}", value),
Err(error) => println!("Error: {}", error),
}
Use unwrap()
to get the value, but be cautious as it panics on errors:
let value = result.unwrap(); // Panics if result is Err
Use the ?
operator for error propagation in functions that return Result
:
fn process_data() -> Result<(), MyError> {
let data = fetch_data()?;
process(data)?;
Ok(())
}
Result
for operations that can fail.Result
over panicking for recoverable errors.Result
with custom error types for more expressive error handling.?
operator to simplify error propagation in functions.The Result
enum is a powerful tool in Rust's error handling arsenal. It encourages explicit error handling and helps create more robust and reliable code. By mastering Result
, you'll be better equipped to write Rust programs that gracefully handle both success and failure scenarios.