Custom error types in Rust - Step-by-Step Execution

Concept Flow - Custom error types

Define struct or enum for error

↓

Implement std::fmt::Display

↓

Implement std::error::Error

↓

Use error type in functions

↓

Return Result<T, CustomError>

↓

Handle error with match or ? operator

↓

End

Create a custom error type by defining a struct or enum, implement Display and Error traits, then use it in functions returning Result to handle errors clearly.

Execution Sample

Rust

use std::fmt;

#[derive(Debug)]
enum MyError {
    NotFound,
    InvalidInput(String),
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MyError::NotFound => write!(f, "Item not found"),
            MyError::InvalidInput(msg) => write!(f, "Invalid input: {}", msg),
        }
    }
}

impl std::error::Error for MyError {}

fn find_item(id: i32) -> Result<String, MyError> {
    if id == 0 {
        Err(MyError::NotFound)
    } else if id < 0 {
        Err(MyError::InvalidInput("negative id".to_string()))
    } else {
        Ok("Item found".to_string())
    }
}

fn main() {
    match find_item(-1) {
        Ok(item) => println!("{}", item),
        Err(e) => println!("Error: {}", e),
    }
}

Defines a custom error enum with two variants, implements Display and Error traits, then uses it in a function returning Result to handle errors.

Execution Table

Step	Code Line	Action	Variable/State	Output/Result
1	Define enum MyError	Create custom error type with variants NotFound and InvalidInput	MyError enum defined
2	Implement Display for MyError	Define how error messages are shown	Display trait implemented
3	Implement Error for MyError	Mark MyError as an error type	Error trait implemented
4	Call find_item(-1)	Start function with id = -1	id = -1
5	Check if id == 0	Condition false	id = -1
6	Check if id < 0	Condition true	id = -1	Return Err(MyError::InvalidInput("negative id"))
7	Match in main on Result	Err branch taken	e = InvalidInput("negative id")	Print: Error: Invalid input: negative id
8	Program ends	No more code

💡 Function returns Err variant because id < 0 condition is true, main prints error message and program ends.

Variable Tracker

Variable	Start	After Step 4	After Step 6	Final
id	undefined	-1	-1	-1
Result from find_item	undefined	pending	Err(MyError::InvalidInput("negative id"))	Err(MyError::InvalidInput("negative id"))
e (error in main)	undefined	undefined	InvalidInput("negative id")	InvalidInput("negative id")

Key Moments - 3 Insights

Why do we implement the Display trait for the custom error?

Implementing Display lets us define the error message shown when printing the error, as seen in execution_table step 7 where the error message is printed.

What happens if the function returns Err? How is it handled?

When find_item returns Err (step 6), main matches on the Result and takes the Err branch (step 7), printing the error message instead of panicking.

Why use an enum for custom errors instead of just a struct?

An enum lets us represent different kinds of errors in one type, like NotFound and InvalidInput, making error handling clearer and more flexible (step 1).

Visual Quiz - 3 Questions

Look at the execution_table at step 6. What error variant is returned by find_item(-1)?

A MyError::InvalidInput("negative id")

B MyError::NotFound

C Ok("Item found")

D None

💡 Hint

Check the 'Output/Result' column at step 6 in the execution_table.

At which step does the main function print the error message?

A Step 5

B Step 7

C Step 4

D Step 8

💡 Hint

Look for the step where 'Print: Error: Invalid input: negative id' appears in the execution_table.

If find_item was called with id = 0, what would be the returned error variant?

A Ok("Item found")

B MyError::InvalidInput("negative id")

C MyError::NotFound

D No error

💡 Hint

Refer to the condition checks in the code and execution_table steps 5 and 6.

Concept Snapshot

Define a custom error type using enum or struct.
Implement fmt::Display to show error messages.
Implement std::error::Error to mark it as an error.
Use Result<T, CustomError> in functions.
Handle errors with match or ? operator.

Full Transcript

This example shows how to create custom error types in Rust. We define an enum MyError with variants NotFound and InvalidInput. We implement the Display trait to control how error messages appear when printed. We also implement the Error trait to mark MyError as a proper error type. The function find_item returns a Result with our custom error. It returns Err with NotFound if id is zero, Err with InvalidInput if id is negative, or Ok if id is positive. In main, we call find_item with -1, which triggers the InvalidInput error. We match on the Result and print the error message. This step-by-step trace shows how variables change and how errors flow through the program.