Struct `Error`

struct Error { ... }

An error that can occur in this crate.

The most common type of error is a result of overflow. But other errors exist as well:

Time zone database lookup failure.
Configuration problem. (For example, trying to round a span with calendar units without providing a relative datetime.)
An I/O error as a result of trying to open a time zone database from a directory via TimeZoneDatabase::from_dir.
Parse errors.

Introspection is limited

Other than implementing the std::error::Error trait when the std feature is enabled, the core::fmt::Debug trait and the core::fmt::Display trait, this error type currently provides no introspection capabilities.

Design

This crate follows the "One True God Error Type Pattern," where only one error type exists for a variety of different operations. This design was chosen after attempting to provide finer grained error types. But finer grained error types proved difficult in the face of composition.

More about this design choice can be found in a GitHub issue about error types.

Implementations

`impl Clone for Error`

fn clone(self: &Self) -> Error

`impl Debug for Error`

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

`impl Display for Error`

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

`impl Error for Error`

`impl Freeze for Error`

`impl RefUnwindSafe for Error`

`impl Send for Error`

`impl Sync for Error`

`impl Unpin for Error`

`impl UnsafeUnpin for Error`

`impl UnwindSafe for Error`

`impl<T> Any for Error`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Error`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Error`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Error`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Error`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Error`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> ToString for Error`

fn to_string(self: &Self) -> String

`impl<T, U> Into for Error`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Error`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Error`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>