Skip to content

13.1. Error Handling.md

Latest commit

 

History

History
89 lines (65 loc) · 3.3 KB

13.1. Error Handling.md

File metadata and controls

89 lines (65 loc) · 3.3 KB

Error Handling in Rust: Mastering the Result Enum

Understanding the Result Enum

The Result enum is a generic type defined in the standard library. It has two variants:

  • Ok(T): Represents successful execution, containing a value of type T.
  • Err(E): Represents an error, containing an error value of type E.

When a function encounters an error condition, it returns a Result with an Err variant. The calling code then handles the error appropriately.

Using Result in Your Code

Here's how you can use the Result enum:

  1. Define Error Types: Create custom error types to represent different error scenarios specific to your program. These error types can implement the std::error::Error trait for consistent error handling.

  2. Functions Returning Result: Functions that might encounter errors should declare their return type as Result<T, E>, where T is the type of the success value and E is the type of the error value.

  3. Handling Errors with match: Utilize the match expression to analyze the returned Result value. You can handle the success case (Ok) and extract the successful value, or handle the error case (Err) and perform appropriate actions like logging the error or returning an error to the caller.

  4. Propagating Errors: If a function encounters an error and wants to propagate it to the caller, it simply returns the received Err variant. This allows errors to be handled at the appropriate level in your application.

Example: Error Handling with Result

use std::fs;

fn main() {
    let greeting_file_result = fs::read_to_string("hello.txt");

    match greeting_file_result {
        Ok(file_content) => {
            println!("File read successfully: {:?}", file_content);
        },
        Err(error) => {
            println!("Failed to read file: {:?}", error);
        }
    }
}

Example: Returning a Custom Error

use core::fmt;
use std::{fmt::{Debug, Formatter}, fs};

pub struct FileReadError {

}

fn main() {
    let contents = read_file("hello.txt".to_string());
    match contents {
        Ok(file_content) => {
            println!("File content: {}", file_content);
        },
        Err(error) => {
            println!("Error reading file: {:?}", error);
        }
    }
}

fn read_file(file_path: String) -> Result<String, FileReadError> {
    let greeting_file_result = fs::read_to_string("hello.txt");
    match greeting_file_result {
        Ok(file_content) => {
            Ok(file_content)
        },
        Err(error) => {
            let err = FileReadError {};
            Err(err)
        }
    }
}

Benefits of Using Result

  • Clarity: The Result enum explicitly conveys success or failure, making code easier to read and understand.
  • Safety: Encourages explicit error handling, leading to more robust and predictable programs.
  • Composability: Allows functions to propagate errors seamlessly, promoting modularity in your codebase.
  • Flexibility: The generic nature of Result enables returning various success and error types.

Further Learning: