1.0.0[−][src]Trait sn0int::fmt::Display

pub trait Display {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error>;
}

Format trait for an empty format, {}.

Display is similar to Debug, but Display is for user-facing output, and so cannot be derived.

For more information on formatters, see the module-level documentation.

Examples

Implementing Display on a type:

use std::fmt;

struct Point {
    x: i32,
    y: i32,
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

let origin = Point { x: 0, y: 0 };

println!("The origin is: {}", origin);

Required methods

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter.

Examples

use std::fmt;

struct Position {
    longitude: f32,
    latitude: f32,
}

impl fmt::Display for Position {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.longitude, self.latitude)
    }
}

assert_eq!("(1.987, 2.983)".to_owned(),
           format!("{}", Position { longitude: 1.987, latitude: 2.983, }));

Loading content...

Implementations on Foreign Types

`impl Display for ExitStatus`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_> Display for Display<'_>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for IntoStringError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TryRecvError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for RecvError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_, T> Display for RwLockWriteGuard<'_, T> where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SocketAddrV6`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_, T> Display for MutexGuard<'_, T> where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for RecvTimeoutError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Ipv4Addr`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for IpAddr`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for PoisonError<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SocketAddrV4`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_, T> Display for RwLockReadGuard<'_, T> where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for TryLockError<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for SendError<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NulError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for AccessError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for FromBytesWithNulError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for AddrParseError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for TrySendError<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for VarError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<W> Display for IntoInnerError<W>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Backtrace`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SocketAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Ipv6Addr`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for JoinPathsError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for StripPrefixError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SystemTimeError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for EscapeDebug<'a>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TryFromIntError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for DecodeUtf16Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for LayoutErr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroI16`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Utf8Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for CharTryFromError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TryFromSliceError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroU128`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroI64`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroI32`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for EscapeDefault`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_, T> Display for &'_ mut T where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for BorrowError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for EscapeDebug`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for BorrowMutError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroI128`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Infallible`[src]

`fn fmt(&self, &mut Formatter) -> Result<(), Error>`[src]

`impl<'_, T> Display for RefMut<'_, T> where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for CannotReallocInPlace`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for AllocErr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_, T> Display for Ref<'_, T> where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroU64`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseBoolError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_> Display for Arguments<'_>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for EscapeUnicode<'a>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroIsize`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseFloatError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseIntError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroI8`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroU8`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroU32`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Utf8Lossy`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for EscapeDefault`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseCharError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for Wrapping<T> where T: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ToUppercase`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Pin where P: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ToLowercase`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for EscapeDefault<'a>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_> Display for PanicInfo<'_>`[src]

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for EscapeUnicode`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_, T> Display for &'_ T where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroU16`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_> Display for Location<'_>`[src]

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NonZeroUsize`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for Rc<T> where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for Arc<T> where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for FromUtf16Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for String`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for Box<T> where T: Display + ?Sized,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for FromUtf8Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'_, B> Display for Cow<'_, B> where B: Display + ToOwned + ?Sized, ::Owned: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for SymbolName<'a>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for Demangle<'a>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Backtrace`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<D> Display for Context<D> where D: 'static + Send + Sync + Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<E> Display for Compat<E> where E: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for SyncFailure<T> where T: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for SymbolName<'a>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for BytesOrWideString<'a>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for Demangle<'a>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for SetLoggerError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseLevelError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for LevelFilter`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<'n, 'e> Display for App<'n, 'e>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for ANSIGenericString<'a, str>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Prefix`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a> Display for ANSIGenericStrings<'a, str>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Infix`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Suffix`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for RunMigrationsError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a, T, DB> Display for DebugQuery<'a, T, DB> where DB: Backend, T: QueryFragment<DB>, <DB as Backend>::QueryBuilder: Default,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ConnectionError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for UnexpectedNullError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for MigrationError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NaiveDateTime`[src]

The Debug output of the naive date and time dt is same to dt.format("%Y-%m-%d %H:%M:%S%.f").

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn't matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveDate;

let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
assert_eq!(format!("{}", dt), "2016-11-15 07:39:24");

Leap seconds may also be used.

let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
assert_eq!(format!("{}", dt), "2015-06-30 23:59:60.500");

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a, I> Display for DelayedFormat where I: Clone + Iterator<Item = Item<'a>>,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NaiveTime`[src]

The Display output of the naive time t is same to t.format("%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn't matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveTime;

assert_eq!(format!("{}", NaiveTime::from_hms(23, 56, 4)),              "23:56:04");
assert_eq!(format!("{}", NaiveTime::from_hms_milli(23, 56, 4, 12)),    "23:56:04.012");
assert_eq!(format!("{}", NaiveTime::from_hms_micro(23, 56, 4, 1234)),  "23:56:04.001234");
assert_eq!(format!("{}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");

Leap seconds may also be used.

assert_eq!(format!("{}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for FixedOffset`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NaiveDate`[src]

The Display output of the naive date d is same to d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

Example

use chrono::NaiveDate;

assert_eq!(format!("{}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
assert_eq!(format!("{}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Utc`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<Tz> Display for DateTime<Tz> where Tz: TimeZone, <Tz as TimeZone>::Offset: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<Tz> Display for Date<Tz> where Tz: TimeZone, <Tz as TimeZone>::Offset: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for OutOfRangeError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for TmFmt<'a>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Duration`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SteadyTime`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseFloatError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for Unexpected<'a>`[src]

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for dyn Expected + 'a`[src]

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for MigrationFileName<'a>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a> Display for MigrationName<'a>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for RecvError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SelectTimeoutError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for SendError<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for RecvTimeoutError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for TrySendError<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TryRecvError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TrySelectError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for SendTimeoutError<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a, T> Display for ShardedLockReadGuard<'a, T> where T: Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, T> Display for ShardedLockWriteGuard<'a, T> where T: Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for SyntaxViolation`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<S> Display for Host<S> where S: AsRef<str>,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Url`[src]

Display the serialization of this URL.

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Decompositions where I: Clone + Iterator<Item = char>,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Recompositions where I: Clone + Iterator<Item = char>,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a> Display for PercentEncode<'a>`[src]

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for LuaError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Void`[src]

`fn fmt(&self, _f: &mut Formatter) -> Result<(), Error>`[src]

`impl<E> Display for LuaFunctionCallError<E> where E: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidHeaderName`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Scheme`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Method`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidStatusCode`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Authority`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidUri`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidHeaderValue`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidHeaderNameBytes`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ToStrError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for PathAndQuery`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for Port<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidUriBytes`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidUriParts`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for HeaderName`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Uri`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for StatusCode`[src]

Formats the status code, including the canonical reason.

Example

assert_eq!(format!("{}", StatusCode::OK), "200 OK");

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidMethod`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidHeaderValueBytes`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<L, R> Display for Either<L, R> where L: Display, R: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidNameError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Name`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for SendError<T>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for ReuniteError<T>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T, E> Display for SendError<T, E>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Canceled`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for TrySendError<T>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for SendError<T>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<E> Display for SharedError<E> where E: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Reason`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for String<T> where T: AsRef<[u8]>,` [src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for CollectBytesError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for CollectVecError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidChunkSize`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for FrameTooBig`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for RunTimeoutError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TurnError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for RunError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for BlockError<T>`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for EnterError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SpawnError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a, T> Display for ShardedLockReadGuard<'a, T> where T: Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, T> Display for ShardedLockWriteGuard<'a, T> where T: Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for ParkError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for BlockingError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for PopError`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<T> Display for PushError<T>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for SetFallbackError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a, R, G, T> Display for ReentrantMutexGuard<'a, R, G, T> where G: 'a + GetThreadId, R: 'a + RawMutex, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, R, T> Display for RwLockReadGuard<'a, R, T> where R: 'a + RawRwLock, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, R, T> Display for MappedMutexGuard<'a, R, T> where R: 'a + RawMutex, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, R, G, T> Display for MappedReentrantMutexGuard<'a, R, G, T> where G: 'a + GetThreadId, R: 'a + RawMutex, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, R, T> Display for RwLockUpgradableReadGuard<'a, R, T> where R: 'a + RawRwLockUpgrade, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, R, T> Display for MappedRwLockWriteGuard<'a, R, T> where R: 'a + RawRwLock, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, R, T> Display for MutexGuard<'a, R, T> where R: 'a + RawMutex, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, R, T> Display for MappedRwLockReadGuard<'a, R, T> where R: 'a + RawRwLock, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a, R, T> Display for RwLockWriteGuard<'a, R, T> where R: 'a + RawRwLock, T: 'a + Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<T> Display for TrySendError<T> where T: Debug,` [src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for UnboundedRecvError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for UnboundedSendError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TryAcquireError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for RecvError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for RecvError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SendError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for SendError<T> where T: Debug,` [src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TryRecvError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for RecvError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for UnboundedTrySendError<T> where T: Debug,` [src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for AcquireError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for LockGuard<T> where T: Display,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for ThrottleError<T> where T: Error,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for Error<T> where T: Display,` [src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Unspecified`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for KeyRejected`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TLSError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidDNSNameError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for Base64Display<'a>`[src]

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for DecodeError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for ErrorKind`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for ErrorKind`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for LowerName`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for ErrorKind`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for LowerQuery`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for ErrorKind`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for SpecificationError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for DecodeError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for WeightedError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ReadError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Label`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

outputs characters in a safe string manner.

if the string is punycode, i.e. starts with xn--, otherwise it translates to a safe ascii string escaping characters as necessary.

`impl Display for SslErrorStack`

`fn fmt(&self, &mut Formatter) -> Result<(), Error>`

`impl Display for Algorithm`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Unspecified`

`fn fmt(&self, &mut Formatter) -> Result<(), Error>`

`impl Display for ProtoError`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Query`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<S, MF> Display for DnsMultiplexer<S, MF, Box<dyn DnsStreamHandle + 'static>> where MF: MessageFinalizer + Send + Sync + 'static, S: DnsClientStream + 'static,`

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`

`impl Display for ProtoErrorKind`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<S, MF> Display for UdpClientStream<S, MF> where MF: MessageFinalizer, S: Send,`

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`

`impl Display for Name`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for DNSClass`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for SupportedAlgorithms`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for ResponseCode`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<S> Display for TcpClientStream<S> where S: Send + AsyncRead + AsyncWrite,`

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`

`impl Display for RecordType`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for ScopedIp`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for Config`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for ParseError`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for AddrParseError`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for Network`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Value`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

Display a JSON value as a string.

let json = json!({ "city": "London", "street": "10 Downing Street" });

// Compact format:
//
// {"city":"London","street":"10 Downing Street"}
let compact = format!("{}", json);
assert_eq!(compact,
    "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");

// Pretty format:
//
// {
//   "city": "London",
//   "street": "10 Downing Street"
// }
let pretty = format!("{:#}", json);
assert_eq!(pretty,
    "{\n  \"city\": \"London\",\n  \"street\": \"10 Downing Street\"\n}");

`impl Display for Number`[src]

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ModuleID`[src]

`fn fmt(&self, w: &mut Formatter) -> Result<(), Error>`[src]

`impl<A> Display for ArrayString<A> where A: Array<Item = u8>,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for CapacityError<T>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ApiError`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for FileTime`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for UnsupportedPlatformError`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for OpenError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Ipv4Network`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for IpNetwork`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Ipv6Network`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for IpNetworkError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InvalidOutputSize`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for MacError`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for InvalidKeyLength`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ColoredString`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Value`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Datetime`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for DatetimeParseError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for X509Name<'a>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Oid`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for BerTag`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for BigUint`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for BigInt`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseBigIntError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for MaxMindDBError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ImageError`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for Ratio<T> where T: Display + Eq + One,` [src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

Renders as numer/denom. If denom=1, renders as numer.

`impl Display for ParseRatioError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for DecodingError`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for ThreadPoolBuildError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<T> Display for PushError<T>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for PopError`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for EncodingError`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for DecodingError`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for BlendOp`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for DisposeOp`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for MatchingType`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for TiffError`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for TiffUnsupportedError`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for TiffFormatError`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Tag`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Rational`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formatting parameters other than width are not supported.

`impl Display for DateTime`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for SRational`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formatting parameters other than width are not supported.

`impl Display for Selectors`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Selector`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Display for CowRcStr<'a>`

`fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`

`impl<Static> Display for Atom<Static> where Static: StaticAtomSet,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<A> Display for Tendril<UTF8, A> where A: Atomicity,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a> Display for DecodeError<'a>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<'a> Display for BufReadDecoderError<'a>`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl<T> Display for Arc<T> where T: Display + ?Sized,`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for NetlinkAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Ipv6Addr`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TimeSpec`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for UnixAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for IpAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InetAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Pid`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for AlgAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TimeVal`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SockAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Uid`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for LinkAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Errno`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Gid`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Signal`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Ipv4Addr`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Void`

`fn fmt(&self, &mut Formatter) -> Result<(), Error>`

`impl Display for ErrorKind`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Capability`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ErrorKind`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ErrorKind`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a, T> Display for DisplayChain<'a, T> where T: ChainedError,` [src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Errno`

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

`impl Display for Ipv4Addr`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TimeVal`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for AlgAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for InetAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Uid`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for VsockAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Errno`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for LinkAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for IpAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for UnixAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Ipv6Addr`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for NetlinkAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for TimeSpec`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Pid`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Gid`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for SockAddr`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Signal`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for ParseError`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Error`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl Display for Regex`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

Shows the original regular expression.

`impl Display for Regex`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

Shows the original regular expression.

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Hir`

Print a display representation of this Hir.

The result of this is a valid regular expression pattern string.

This implementation uses constant stack space and heap space proportional to the size of the Hir.

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for CaseFoldError`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Error`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for UnicodeWordError`

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

`impl Display for Ast`

Print a display representation of this Ast.

This does not preserve any of the original whitespace formatting that may have originally been present in the concrete syntax from which this Ast was generated.

This implementation uses constant stack space and heap space proportional to the size of the Ast.