Custom error types in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code with a custom error?

Look at this Rust code that defines a custom error and uses it in a function. What will it print?

Rust

use std::fmt;

#[derive(Debug)]
struct MyError {
    details: String,
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Error: {}", self.details)
    }
}

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

fn might_fail(fail: bool) -> Result<&'static str, MyError> {
    if fail {
        Err(MyError { details: String::from("Something went wrong") })
    } else {
        Ok("Success")
    }
}

fn main() {
    match might_fail(true) {
        Ok(msg) => println!("{}", msg),
        Err(e) => println!("{}", e),
    }
}

A panic occurred: Something went wrong

B Error: Something went wrong

C Success

D Compilation error due to missing trait implementation

💡 Hint

Check what the Err variant prints using the Display trait.

The function returns an Err with MyError. The Display trait prints "Error: Something went wrong".

❓ Predict Output

intermediate

What does this Rust code print when no error occurs?

This code uses a custom error type but calls the function with false. What is printed?

Rust

use std::fmt;

#[derive(Debug)]
struct MyError {
    details: String,
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Error: {}", self.details)
    }
}

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

fn might_fail(fail: bool) -> Result<&'static str, MyError> {
    if fail {
        Err(MyError { details: String::from("Something went wrong") })
    } else {
        Ok("Success")
    }
}

fn main() {
    match might_fail(false) {
        Ok(msg) => println!("{}", msg),
        Err(e) => println!("{}", e),
    }
}

A Success

B Error: Something went wrong

C panic occurred: Something went wrong

D Compilation error due to missing trait implementation

💡 Hint

Look at the Ok branch of the match.

When fail is false, the function returns Ok("Success"), so it prints "Success".

❓ Predict Output

advanced

What error does this Rust code raise?

This code tries to create a custom error but forgets to implement a trait. What error occurs?

Rust

struct MyError {
    details: String,
}

fn main() {
    let err = MyError { details: String::from("Oops") };
    println!("{}", err);
}

A No error, prints: Oops

B error[E0382]: use of moved value: `err`

C error[E0277]: `MyError` doesn't implement `std::fmt::Display`

D error[E0425]: cannot find value `err` in this scope

💡 Hint

Printing with {} requires the Display trait.

The struct MyError does not implement Display, so printing it with {} causes a compile error.

🧠 Conceptual

advanced

Which statement about custom error types in Rust is true?

Choose the correct statement about creating and using custom error types in Rust.

A Custom error types must implement the <code>std::error::Error</code> trait to be used with <code>Result</code>.

B Implementing <code>std::fmt::Display</code> is optional for custom error types.

C Custom error types can only hold string data and nothing else.

D You cannot use <code>match</code> to handle custom error types.

💡 Hint

Think about what traits Rust expects for error handling.

To use a custom error type with Result and error handling libraries, it must implement std::error::Error. Implementing Display is also required for user-friendly messages.

❓ Predict Output

expert

What is the output of this Rust code with nested custom errors?

This Rust code defines two custom error types and nests one inside the other. What will it print?

Rust

use std::fmt;

#[derive(Debug)]
struct InnerError {
    msg: String,
}

impl fmt::Display for InnerError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Inner error: {}", self.msg)
    }
}

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

#[derive(Debug)]
struct OuterError {
    source: InnerError,
}

impl fmt::Display for OuterError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Outer error caused by: {}", self.source)
    }
}

impl std::error::Error for OuterError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(&self.source)
    }
}

fn main() {
    let inner = InnerError { msg: String::from("disk failure") };
    let outer = OuterError { source: inner };
    println!("{}", outer);
}

A Compilation error due to missing lifetime annotations

B Inner error: disk failure

C Outer error caused by: disk failure

D Outer error caused by: Inner error: disk failure

💡 Hint

Look at how Display is implemented for OuterError.

The OuterError prints its message and then calls Display on its source, which is InnerError. So the output combines both messages.