Rust takes error handling seriously.

Instead of relying heavily on exceptions, Rust encourages developers to handle errors explicitly using types such as:

• Result<T, E>
• Option<T>
• panic!

These tools help developers write safer and more predictable programs.

The key idea is simple:

• Use Result when an operation can succeed or fail.
• Use Option when a value may or may not exist.
• Use panic! when the program reaches a state it cannot reasonably recover from.

This guide explains each approach with simple examples.

---

What Is Error Handling in Rust?

Error handling means deciding what your program should do when something goes wrong.

Common examples include:

• A file does not exist
• User input is invalid
• A network request fails
• A database query returns nothing
• Division by zero is attempted
• A required value is missing

Rust generally separates errors into two categories:

Recoverable Errors

These are problems the program can handle.

Examples:

• File not found
• Invalid input
• Failed API request

Rust commonly uses:

Result<T, E>

for recoverable errors.

Unrecoverable Errors

These are situations where continuing execution may not make sense.

Rust commonly uses:

panic!

for these situations.

---

What Is Result<T, E> in Rust?

Result<T, E> is an enum used for operations that may succeed or fail.

Its basic structure is:

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Here:

• T is the success value type.
• E is the error type.

If the operation succeeds, Rust returns:

Ok(value)

If the operation fails, Rust returns:

Err(error)

---

Simple Result Example

Consider a division function.

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

Now use it:

fn main() {
    let result = divide(10, 2);

    match result {
        Ok(value) => println!("Result: {}", value),
        Err(error) => println!("Error: {}", error),
    }
}

Output:

Result: 5

If you call:

divide(10, 0)

the result becomes:

Error: Cannot divide by zero

---

Handling Result with match

The match expression is one of the clearest ways to handle Result.

Example:

fn main() {
    let result: Result<i32, &str> = Ok(100);

    match result {
        Ok(value) => {
            println!("Success: {}", value);
        }
        Err(error) => {
            println!("Error: {}", error);
        }
    }
}

This forces you to consider both possible outcomes.

---

Result with File Operations

File operations can fail, so Rust returns a Result.

Example:

use std::fs::File;

fn main() {
    let file = File::open("data.txt");

    match file {
        Ok(file) => {
            println!("File opened successfully");
        }
        Err(error) => {
            println!("Failed to open file: {}", error);
        }
    }
}

If the file exists, the program receives an Ok.

If it does not exist, the program receives an Err.

---

What Is unwrap()?

unwrap() extracts the value inside Ok.

Example:

fn main() {
    let result: Result<i32, &str> = Ok(50);

    let value = result.unwrap();

    println!("{}", value);
}

Output:

50

However, if the value is:

Err("Something went wrong")

then unwrap() causes the program to panic.

Example:

fn main() {
    let result: Result<i32, &str> = Err("Failed");

    let value = result.unwrap();
}

This causes a runtime panic.

For this reason, unwrap() should be used carefully.

---

What Is expect()?

expect() works similarly to unwrap(), but lets you provide a custom error message.

Example:

use std::fs::File;

fn main() {
    let file = File::open("data.txt")
        .expect("Could not open data.txt");
}

If the file cannot be opened, Rust displays your custom message.

This makes expect() more descriptive than unwrap().

---

What Is the ? Operator?

The ? operator makes error propagation much easier.

Instead of manually matching every Result, you can return the error to the calling function.

Example:

use std::fs::File;
use std::io;

fn open_file() -> Result<File, io::Error> {
    let file = File::open("data.txt")?;

    Ok(file)
}

The ? operator means:

If successful:
Continue

If error:
Return the error immediately

This is much shorter than writing a full match.

---

Without the ? Operator

The same code can be written manually:

use std::fs::File;
use std::io;

fn open_file() -> Result<File, io::Error> {
    let file = match File::open("data.txt") {
        Ok(file) => file,
        Err(error) => return Err(error),
    };

    Ok(file)
}

Using ? makes the function easier to read.

---

What Is Option in Rust?

Option<T> is used when a value may or may not exist.

Its structure is:

enum Option<T> {
    Some(T),
    None,
}

Here:

• Some(T) means a value exists.
• None means there is no value.

---

Simple Option Example

fn find_user(id: i32) -> Option<String> {
    if id == 1 {
        Some(String::from("Ankit"))
    } else {
        None
    }
}

Now use it:

fn main() {
    let user = find_user(1);

    match user {
        Some(name) => println!("User: {}", name),
        None => println!("User not found"),
    }
}

Output:

User: Ankit

---

Option Example with Vec

The get() method on a vector returns an Option.

Example:

fn main() {
    let numbers = vec![10, 20, 30];

    let value = numbers.get(1);

    match value {
        Some(number) => println!("Value: {}", number),
        None => println!("Index not found"),
    }
}

Output:

Value: 20

If you request an invalid index:

numbers.get(10)

Rust returns:

None

instead of crashing.

---

Option vs Result

Option and Result may look similar, but they solve different problems.

Use Option when the only question is:

Does a value exist?

Use Result when you need to know:

Did the operation succeed?
If not, why did it fail?

Example:

Option<String>

might represent:

Some("Ankit")
None

While:

Result<String, String>

might represent:

Ok("Ankit")
Err("Database connection failed")

---

Option with unwrap()

You can also use unwrap() with Option.

Example:

fn main() {
    let name = Some("Rust");

    println!("{}", name.unwrap());
}

Output:

Rust

But:

let name: Option<&str> = None;
name.unwrap();

will panic.

So the same warning applies.

---

Option with unwrap_or()

unwrap_or() provides a default value when the Option is None.

Example:

fn main() {
    let name: Option<&str> = None;

    let value = name.unwrap_or("Guest");

    println!("{}", value);
}

Output:

Guest

This is often safer than calling unwrap().

---

Option with if let

If you only care about one pattern, if let can make the code shorter.

Example:

fn main() {
    let age = Some(25);

    if let Some(value) = age {
        println!("Age: {}", value);
    }
}

This is useful when you do not need to handle every possible pattern explicitly.

---

What Is panic! in Rust?

panic! stops normal program execution when Rust encounters an unrecoverable problem.

Example:

fn main() {
    panic!("Something went wrong");
}

Running this program causes a panic and terminates the current thread.

You can also include values in the panic message.

fn main() {
    let age = -1;

    if age < 0 {
        panic!("Invalid age: {}", age);
    }
}

---

When Should You Use panic!?

panic! should generally be used when the program reaches a state that should never happen or cannot safely continue.

Examples include:

• Broken internal assumptions
• Impossible program states
• Invalid hardcoded configuration
• Serious programmer errors

For expected failures such as user input errors, file errors, or network failures, prefer Result.

---

Example: Result vs panic!

Consider division.

Using panic!:

fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Cannot divide by zero");
    }

    a / b
}

This stops execution when b is zero.

A safer version uses Result:

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

Now the caller decides how to handle the problem.

This is usually better for recoverable errors.

---

panic! and Array Indexing

Some Rust operations can panic automatically.

Example:

fn main() {
    let numbers = [10, 20, 30];

    println!("{}", numbers[10]);
}

This attempts to access an invalid array index.

Rust will panic instead of allowing unsafe memory access.

A safer alternative is:

fn main() {
    let numbers = [10, 20, 30];

    match numbers.get(10) {
        Some(value) => println!("{}", value),
        None => println!("Index does not exist"),
    }
}

---

unwrap() vs expect() vs Proper Error Handling

Consider:

let file = File::open("data.txt").unwrap();

This is short, but the program panics if the file is missing.

Using expect():

let file = File::open("data.txt")
    .expect("Failed to open data.txt");

This provides a clearer panic message.

For recoverable situations, proper handling is better:

match File::open("data.txt") {
    Ok(file) => println!("File opened"),
    Err(error) => println!("Error: {}", error),
}

The best choice depends on whether failure is expected and recoverable.

---

Propagating Errors with Result

Sometimes a function should not handle the error itself.

Instead, it can return the error to another function.

Example:

use std::fs::File;
use std::io;

fn load_file() -> Result<File, io::Error> {
    File::open("data.txt")
}

The calling function can then decide what to do.

fn main() {
    match load_file() {
        Ok(_) => println!("File loaded"),
        Err(error) => println!("Error: {}", error),
    }
}

This is called error propagation.

---

Returning Result from main()

Rust also allows main() to return a Result.

Example:

use std::fs::File;
use std::io;

fn main() -> Result<(), io::Error> {
    let _file = File::open("data.txt")?;

    println!("File opened");

    Ok(())
}

This makes the ? operator convenient even inside main().

---

Converting Option into Result

Sometimes you start with an Option, but you want to provide an error message.

You can use ok_or().

Example:

fn find_username(id: i32) -> Option<&'static str> {
    if id == 1 {
        Some("Ankit")
    } else {
        None
    }
}

fn get_username(id: i32) -> Result<&'static str, &'static str> {
    find_username(id).ok_or("User not found")
}

Now a missing value becomes a proper error.

---

Useful Result Methods

Rust provides several useful methods for Result.

For example:

unwrap()
expect()
unwrap_or()
is_ok()
is_err()
ok()
err()

Example:

fn main() {
    let result: Result<i32, &str> = Ok(10);

    println!("{}", result.is_ok());
}

Output:

true

---

Useful Option Methods

Common Option methods include:

unwrap()
expect()
unwrap_or()
is_some()
is_none()
map()
ok_or()

Example:

fn main() {
    let value = Some(10);

    println!("{}", value.is_some());
}

Output:

true

---

Error Handling Example with User Input

Here is a simple parsing example.

fn parse_number(value: &str) -> Result<i32, std::num::ParseIntError> {
    value.parse::<i32>()
}

Usage:

fn main() {
    match parse_number("100") {
        Ok(number) => println!("Number: {}", number),
        Err(error) => println!("Invalid number: {}", error),
    }
}

If the string contains invalid numeric data, Rust returns an error instead of silently failing.

---

Result, Option and panic! Comparison

Feature	Result	Option	panic!
Represents success/failure	Yes	No	No
Represents missing value	Possible, but not primary use	Yes	No
Contains error information	Yes	No	Panic message
Recoverable	Yes	Yes	Usually no
Stops program execution	No	No	Yes
Common use	Operations that can fail	Optional values	Unrecoverable states

---

When to Use Result

Use Result when an operation can fail and you want to explain the failure.

Common examples:

• Opening files
• Network requests
• Parsing data
• Database operations
• API calls
• User validation
• Writing files

Example:

Result<User, DatabaseError>

This tells the caller whether the operation succeeded and, if not, what went wrong.

---

When to Use Option

Use Option when a value may legitimately be absent.

Examples include:

• Searching for an item
• Looking up a user
• Optional configuration
• Optional database fields
• Accessing collection values safely

Example:

Option<User>

This means:

User exists
or
User does not exist

There is no need to provide an error reason.

---

When to Use panic!

Use panic! when continuing the program would be inappropriate.

Good examples include:

• Broken assumptions
• Impossible internal states
• Invalid fixed configuration
• Serious programming mistakes

Avoid using panic! for normal expected failures.

For example, a missing user should usually not cause the entire application to panic.

---

Best Practices for Rust Error Handling

Prefer Result for operations that may fail during normal application usage.

Use Option when a missing value is valid and does not require an explanation.

Avoid excessive use of:

unwrap()

in production code when the error can realistically occur.

Use expect() when a panic is acceptable but you want a clear explanation.

Use the ? operator to keep error propagation concise.

Return errors to callers when the caller is better positioned to decide how to handle them.

Use panic! mainly for unrecoverable conditions and broken program assumptions.

---

Simple Decision Guide

Use:

Result<T, E>

when:

Something can fail and you need an error reason.

Use:

Option<T>

when:

A value may simply not exist.

Use:

panic!

when:

The program cannot safely or logically continue.

---

Final Thoughts

Rust error handling is built around explicit and type-safe error management.

The three most important tools are:

Result<T, E> for recoverable operations that can succeed or fail.

Option<T> for values that may or may not exist.

panic! for unrecoverable situations where normal execution should stop.

For beginners, the most important rule is simple:

Expected failure → Result

Missing value → Option

Unrecoverable problem → panic!

Learning how to use Result, Option, match, and the ? operator correctly will help you write safer and more reliable Rust programs.