pub struct Err {
pub file: &'static str,
pub line: u32,
/* private fields */
}Expand description
Is the struct that represents an error with a reason.
This struct encapsulates the reason for the error, which can be any data type. Typically, the reason is an enum variant, which makes it easy to uniquely identify the error kind and location in the source code. In addition, since an enum variant can store additional information as their fields, it is possible to provide more detailed information about the error.
The reason for the error can be distinguished with match statements, and type casting, so it is easy to handle the error in a type-safe manner.
This struct also contains an optional cause error, which is the error caused the current error. This is useful for chaining errors.
This struct is implements the std::errors::Error trait, so it can be used as an
common error type in Rust programs.
Fields§
§file: &'static strThe name of the source file where the error occurred.
line: u32The line number in the source file where the error occurred.
Implementations§
Source§impl Err
impl Err
Sourcepub fn new<R>(reason: R) -> Self
pub fn new<R>(reason: R) -> Self
Creates a new Err instance with the given reason.
The reason can be of any type, but typically it is an enum variant that uniquely identifies the error’s nature.
§Parameters
reason: The reason for the error.
§Returns
A new Err instance containing the given reason.
use errs::Err;
#[derive(Debug)]
enum Reasons {
IllegalState { state: String },
}
let err = Err::new(Reasons::IllegalState { state: "bad state".to_string() });Sourcepub fn with_source<R, E>(reason: R, source: E) -> Self
pub fn with_source<R, E>(reason: R, source: E) -> Self
Creates a new Err instance with the give reason and underlying source error.
This constructor is useful when the error is caused by another error.
§Parameters
reason: The reason for the error.source: The underlying source error that caused the error.
§Returns
A new Err instance containing the given reason and source error.
use errs::Err;
use std::io;
#[derive(Debug)]
enum Reasons {
FailToDoSomething,
}
let io_error = io::Error::other("oh no!");
let err = Err::with_source(Reasons::FailToDoSomething, io_error);Sourcepub fn reason<R>(&self) -> Result<&R, &Self>
pub fn reason<R>(&self) -> Result<&R, &Self>
Attempts to retrieve the error’s reason as a specific type.
This method checks whether the stored reason matches the specified type and returns a reference to the reason if the type matches.
§Parameters
R: The expected type of the reason.
§Returns
Ok(&R): A reference to the reason if it is of the specified type.Err(&self): A reference to thisErritself if the reason is not of the specified type.
use errs::Err;
#[derive(Debug)]
enum Reasons {
IllegalState { state: String },
}
let err = Err::new(Reasons::IllegalState { state: "bad state".to_string() });
match err.reason::<Reasons>() {
Ok(r) => match r {
Reasons::IllegalState { state } => println!("state = {state}"),
_ => { /* ... */ }
}
Err(err) => match err.reason::<String>() {
Ok(s) => println!("string reason = {s}"),
Err(_err) => { /* ... */ }
}
}Sourcepub fn match_reason<R>(&self, func: fn(&R)) -> &Self
pub fn match_reason<R>(&self, func: fn(&R)) -> &Self
Executes a function if the error’s reason matches a specific type.
This method allows you to perform actions based on the type of the error’s reason. If the reason matches the expected type, the provided function is called with a reference to the reason.
§Parameters
R: The expected type of the reason.func: The function to execute if the reason matches the type.
§Returns
A reference to the current Err instance.
use errs::Err;
#[derive(Debug)]
enum Reasons {
IllegalState { state: String },
}
let err = Err::new(Reasons::IllegalState { state: "bad state".to_string() });
err.match_reason::<Reasons>(|r| match r {
Reasons::IllegalState { state } => println!("state = {state}"),
_ => { /* ... */ }
})
.match_reason::<String>(|s| {
println!("string reason = {s}");
});