\n\nThis page has been machine-translated from the original page.
\n
This time, I will briefly summarize what Rust’s thiserror crate is and how to use it.
Reference: thiserror - Rust
\n\nthiserror is a crate (a library in Rust) for concisely implementing the Rust std::error::Error trait (which defines common methods across different types) with derive macros (which automatically generate trait implementation code for structs and enums).
anyhow is another useful crate for error handling in Rust, but compared with anyhow, thiserror has advantages when implementing custom error types. It is commonly used in libraries where error types need to be explicitly exposed so callers can distinguish them.
Reference: thiserror vs anyhow, the error-handling holy war #Rust - Qiita
\nTo begin with, Rust does not have try-catch style error handling, and errors are represented with the Result<T, E> type.
enum Result<T, E> {\n Ok(T), // Value on success\n Err(E), // Value on error\n}Reference: Rust Is Great: Error Handling Edition
\nIn Rust, the Result type is used as the result of operations that may fail.
The following function is a straightforward implementation of error handling when using the read_to_string function.
Rust can use pattern matching with match like this to perform error handling based on the Result return value.
use std::fs;\n\nfn main() -> Result<(), std::io::Error> {\n let content = match fs::read_to_string(\"test.txt\") {\n Ok(text) => text,\n Err(err) => return Err(err),\n };\n println!(\"{}\", content);\n Ok(())\n}Reference: match - Rust By Example
\nIn Rust, using the ? operator lets you write nearly the same Result handling as the match expression above, as shown below.
use std::fs;\n\nfn main() -> Result<(), std::io::Error> {\n let content = fs::read_to_string(\"test.txt\")?;\n println!(\"{}\", content);\n Ok(())\n}Reference: Recoverable Errors with Result - The Rust Programming Language (Japanese Edition)
\nReference: Rust’s ? Operator #Rust - Qiita
\nAlso, similar processing can be implemented like this.
\nuse std::fs;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n let message: String = fs::read_to_string(\"message.txt\")?;\n println!(\"{}\", message);\n Ok(())\n}In the code above, errors are handled using Box<dyn std::error::Error>.
Rust requires a function’s return type to be clear at compile time, but here dyn std::error::Error dynamically dispatches some type that implements the std::error::Error trait.
In such cases, Box is used to point to data stored on the heap.
This makes it possible to use a type even when its size cannot be determined at compile time, and it also lets you receive errors even when different error types may be returned inside the function, as shown below.
\nuse std::fs;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n // io::Error is automatically converted to Box<dyn Error> by ?\n // let content = fs::read_to_string(\"Cargo.toml\")?;\n let content = fs::read_to_string(\"xxx.toml\")?;\n\n // ParseIntError can also be converted to the same Box<dyn Error>\n let port: u16 = content.trim().parse()?;\n\n println!(\"port = {}\", port);\n Ok(())\n}Reference: Returning Traits with dyn - Rust By Example (Japanese Edition)
\nReference: Using Box
When the caller handles errors, using Box<dyn std::error::Error> makes it easy to handle multiple types, but it also has drawbacks, such as making it harder for the caller to determine the error kind.
thiserror makes it easy to implement explicit custom error types, so it is mainly used in library implementations that need to expose error types structurally and allow callers to pattern match on them.
Below is a simple error-handling implementation using thiserror. Here, an enum defines an error called AppError.
The leading #[derive(Debug, Error)] is used to automatically implement the std::error::Error trait.
use thiserror::Error;\n\n#[derive(Debug, Error)]\npub enum AppError {\n #[error(\"I/O エラー: {0}\")]\n Io(#[from] std::io::Error),\n}\n\nfn handle_error(err: &AppError) {\n match err {\n AppError::Io(e) => {\n eprintln!(\"[IO] ファイル操作失敗: {}\", e);\n }\n }\n}\n\nfn read_config(path: &str) -> Result<String, AppError> {\n let content = std::fs::read_to_string(path)?;\n Ok(content)\n}\n\nfn main() {\n\n println!(\"--- 1. 存在しないファイルの読み込み (#[from] による自動変換) ---\");\n match read_config(\"nonexistent.toml\") {\n Ok(content) => println!(\"{}\", content),\n Err(e) => handle_error(&e),\n }\n\n println!(\"\\n--- 2. 存在するファイルの読み込み (#[from] による自動変換) ---\");\n match read_config(\"Cargo.toml\") {\n Ok(content) => println!(\"{}\", content),\n Err(e) => handle_error(&e),\n }\n\n}In the code above, #[from] automatically generates the implementation that converts std::io::Error into AppError, and when errors are propagated with the ? operator, conversion from io::Error to AppError is performed automatically.
I may add more implementation patterns that use thiserror later.