Custom error types in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a custom error type in Rust?

A custom error type is a user-defined type that represents specific error conditions in a program. It helps to handle errors clearly and precisely.

beginner

How do you define a simple custom error type using an enum in Rust?

You define an enum with variants representing different error cases. For example:<br>

enum MyError {
    NotFound,
    InvalidInput,
}

intermediate

Why implement the std::fmt::Display trait for a custom error type?

Implementing Display allows you to provide a user-friendly error message when the error is printed or logged.

intermediate

What trait should a custom error type implement to be compatible with the ? operator?

It should implement the std::error::Error trait. This trait marks the type as an error and allows easy error propagation.

intermediate

How can you add extra information to a custom error variant?

You can add fields to enum variants, for example:<br>

enum MyError {
    IoError(std::io::Error),
    Message(String),
}

Which Rust feature is commonly used to create custom error types?

A struct

B macro

C trait

D enum

Enums let you define different error cases clearly, making them ideal for custom error types.

What trait must a custom error implement to work with the ? operator?

A std::fmt::Display

B Copy

C std::error::Error

D Clone

The std::error::Error trait marks the type as an error and enables the ? operator to propagate it.

Why implement the Display trait for a custom error?

A To allow copying the error

B To provide a readable error message

C To convert the error to a number

D To make the error mutable

Display lets you show a clear, user-friendly message when printing the error.

How can you include an underlying IO error inside a custom error enum?

A By adding a variant with a std::io::Error field

B By implementing Copy trait

C By using a macro

D By defining a struct instead

You add a variant like IoError(std::io::Error) to wrap the underlying error.

What is the main benefit of using custom error types?

A Clear and specific error handling

B Faster program execution

C Less code to write

D Automatic error fixing

Custom errors help you handle different problems clearly and specifically.

Explain how to create and use a custom error type in Rust.

Think about enum, traits, and Result.

Why is implementing the std::error::Error trait important for custom errors?

Consider error propagation and ecosystem compatibility.