pub struct Error { /* private fields */ }
Expand description
Compatibility re-export of Report
for interop with anyhow
Core Diagnostic wrapper type.
§eyre
Users
You can just replace use
s of eyre::Report
with miette::Report
.
Implementations§
source§impl Report
impl Report
sourcepub fn new<E>(error: E) -> Self
pub fn new<E>(error: E) -> Self
Create a new error object from any error type.
The error type must be thread safe and 'static
, so that the Report
will be as well.
If the error type does not provide a backtrace, a backtrace will be created here to ensure that a backtrace exists.
sourcepub fn msg<M>(message: M) -> Self
pub fn msg<M>(message: M) -> Self
Create a new error object from a printable error message.
If the argument implements std::error::Error
, prefer Report::new
instead which preserves the underlying error’s cause chain and
backtrace. If the argument may or may not implement std::error::Error
now or in the future, use miette!(err)
which handles either way
correctly.
Report::msg("...")
is equivalent to miette!("...")
but occasionally
convenient in places where a function is preferable over a macro, such
as iterator or stream combinators:
use futures::stream::{Stream, StreamExt, TryStreamExt};
use miette::{Report, Result};
async fn demo<S>(stream: S) -> Result<Vec<Output>>
where
S: Stream<Item = Input>,
{
stream
.then(ffi::do_some_work) // returns Result<Output, &str>
.map_err(Report::msg)
.try_collect()
.await
}
sourcepub fn new_boxed(error: Box<dyn Diagnostic + Send + Sync + 'static>) -> Self
pub fn new_boxed(error: Box<dyn Diagnostic + Send + Sync + 'static>) -> Self
Create a new error object from a boxed Diagnostic
.
The boxed type must be thread safe and ’static, so that the Report
will be as well.
Boxed Diagnostic
s don’t implement Diagnostic
themselves due to trait coherence issues.
This method allows you to create a Report
from a boxed Diagnostic
.
sourcepub fn wrap_err<D>(self, msg: D) -> Self
pub fn wrap_err<D>(self, msg: D) -> Self
Create a new error from an error message to wrap the existing error.
For attaching a higher level error message to a Result
as it is
propagated, the WrapErr
extension trait may be more
convenient than this function.
The primary reason to use error.wrap_err(...)
instead of
result.wrap_err(...)
via the WrapErr
trait would be if the
message needs to depend on some data held by the underlying error:
sourcepub fn context<D>(self, msg: D) -> Self
pub fn context<D>(self, msg: D) -> Self
Compatibility re-export of wrap_err
for interop with anyhow
sourcepub fn chain(&self) -> Chain<'_>
pub fn chain(&self) -> Chain<'_>
An iterator of the chain of source errors contained by this Report.
This iterator will visit every error in the cause chain of this error object, beginning with the error that this error object was created from.
§Example
use miette::Report;
use std::io;
pub fn underlying_io_error_kind(error: &Report) -> Option<io::ErrorKind> {
for cause in error.chain() {
if let Some(io_error) = cause.downcast_ref::<io::Error>() {
return Some(io_error.kind());
}
}
None
}
sourcepub fn root_cause(&self) -> &(dyn StdError + 'static)
pub fn root_cause(&self) -> &(dyn StdError + 'static)
The lowest level cause of this error — this error’s cause’s cause’s cause etc.
The root cause is the last error in the iterator produced by
chain()
.
sourcepub fn is<E>(&self) -> bool
pub fn is<E>(&self) -> bool
Returns true if E
is the type held by this error object.
For errors constructed from messages, this method returns true if E
matches the type of the message D
or the type of the error on
which the message has been attached. For details about the
interaction between message and downcasting, see here.
sourcepub fn downcast<E>(self) -> Result<E, Self>
pub fn downcast<E>(self) -> Result<E, Self>
Attempt to downcast the error object to a concrete type.
sourcepub fn downcast_ref<E>(&self) -> Option<&E>
pub fn downcast_ref<E>(&self) -> Option<&E>
Downcast this error object by reference.
§Example
// If the error was caused by redaction, then return a tombstone instead
// of the content.
match root_cause.downcast_ref::<DataStoreError>() {
Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
None => Err(error),
}
sourcepub fn downcast_mut<E>(&mut self) -> Option<&mut E>
pub fn downcast_mut<E>(&mut self) -> Option<&mut E>
Downcast this error object by mutable reference.
sourcepub fn handler(&self) -> &dyn ReportHandler
pub fn handler(&self) -> &dyn ReportHandler
Get a reference to the Handler for this Report.
sourcepub fn handler_mut(&mut self) -> &mut dyn ReportHandler
pub fn handler_mut(&mut self) -> &mut dyn ReportHandler
Get a mutable reference to the Handler for this Report.
sourcepub fn with_source_code(
self,
source_code: impl SourceCode + Send + Sync + 'static,
) -> Report
pub fn with_source_code( self, source_code: impl SourceCode + Send + Sync + 'static, ) -> Report
Provide source code for this error