Struct `Error`

struct Error

The error type which is returned from formatting a message into a stream.

This type does not support transmission of an error other than that an error occurred. This is because, despite the existence of this error, string formatting is considered an infallible operation. fmt() implementors should not return this Error unless they received it from their Formatter. The only time your code should create a new instance of this error is when implementing fmt::Write, in order to cancel the formatting operation when writing to the underlying stream fails.

Any extra information must be arranged to be transmitted through some other means, such as storing it in a field to be consulted after the formatting operation has been cancelled. (For example, this is how std::io::Write::write_fmt() propagates IO errors during writing.)

This type, fmt::Error, should not be confused with std::io::Error or std::error::Error, which you may also have in scope.

Examples

use std::fmt::{self, write};

let mut output = String::new();
if let Err(fmt::Error) = write(&mut output, format_args!("Hello {}!", "world")) {
    panic!("An error occurred");
}

Implementations

`impl Clone for Error`

fn clone(self: &Self) -> Error

`impl Copy for Error`

`impl Debug for Error`

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

`impl Default for Error`

fn default() -> Error

`impl Display for Error`

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

`impl Eq for Error`

`impl Error for crate::fmt::Error`

`impl Freeze for Error`

`impl Hash for Error`

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

`impl Ord for Error`

fn cmp(self: &Self, other: &Error) -> $crate::cmp::Ordering

`impl PartialEq for Error`

fn eq(self: &Self, other: &Error) -> bool

`impl PartialOrd for Error`

fn partial_cmp(self: &Self, other: &Error) -> $crate::option::Option<$crate::cmp::Ordering>

`impl RefUnwindSafe for Error`

`impl Send for Error`

`impl StructuralPartialEq for Error`

`impl Sync for Error`

`impl Unpin 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, 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>