Struct Error 

pub struct Error { /* private fields */ }

I/O error mirroring std::io::Error.

Carries an ErrorKind plus an optional message string for context. The rendered Display form is "<kind>" when no message is attached, or "<kind>: <message>" when one is.

Under feature = "std", the From<std::io::Error> bridge below applies a tri-state message-attachment policy so the rendered text matches the information density of the input without paying a heap allocation for plain kind-only inputs:

1. std error carries context (raw_os_error.is_some() OR get_ref().is_some() — the canonical std discriminator for “more than just a kind”) — the std Display output is captured as the message. The original OS / errno / path text survives the conversion and appears after the kind tag.
2. std error is plain kind-only AND we mapped the kind (std::io::Error::from(ErrorKind::NotFound) etc.) — no message is attached. The kind tag already conveys the information; capturing the std Display output would just repeat it ("entity not found: entity not found") and burn a heap allocation on the hot path.
3. std error is plain kind-only but we did NOT map the kind (the #[non_exhaustive] std::io::ErrorKind catch-all branch — e.g. OutOfMemory mapping to our ErrorKind::Other) — the std Display output IS captured so the user-visible discriminant isn’t lost in the Other bucket. Renders as "other error: out of memory" rather than just "other error".

Implementations

impl Error

pub fn new<M: Into<String>>(kind: ErrorKind, message: M) -> Self

Construct an error with the given kind and a context message.

Analogous to std::io::Error::new but intentionally narrower: this constructor takes a String-coercible message and stores it verbatim, where std’s new() accepts E: Into<Box<dyn std::error::Error + Send + Sync>> and carries a chained source via Error::source(). This crate’s error type has no source-chaining surface (and can’t have one under no_std + alloc without an alloc dyn-trait shim), so an analogous “wrap an inner error” helper would be misleading; callers wanting the source payload of a std error use the From<std::io::Error> bridge below, which renders the std Display into the message field.

pub const fn from_kind(kind: ErrorKind) -> Self

Construct an error with only an ErrorKind (no message). Matches std::io::Error::from for ErrorKind.

pub const fn kind(&self) -> ErrorKind

Return the ErrorKind this error carries.

pub fn other<M: Into<String>>(message: M) -> Self

Construct an ErrorKind::Other error carrying message. Mirrors std::io::Error::other.

Trait Implementations

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

Available on crate feature std only.

Bridge from std::io::Error. Maps the std ErrorKind to this crate’s ErrorKind when a variant exists for it, and falls back to ErrorKind::Other for any std variant we don’t track (the std type is #[non_exhaustive], so the catch-all is required). The Display message is captured via the tri-state policy documented on Error: kept for contextful std errors and for unmapped kinds (so the discriminant is preserved even in the Other bucket), dropped for plain kind-only errors whose kind we DO map (to avoid the redundant "<kind>: <kind>" render and the heap allocation). Net effect: ? from std-backed backends propagates the original context to operators, but callers inspecting err.kind() after the conversion should be aware that an unknown std kind now reads as ErrorKind::Other rather than the originating variant.

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

Available on crate feature std only.

Bridge back to std::io::Error so existing call sites that consume std::io::Result<_> (and where From is invoked via ?) keep compiling once their input switches to this module.

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<ErrorKind> for Error

fn from(kind: ErrorKind) -> Self

Converts to this type from the input type.