Trait std::fmt::Debug1.0.0[−][src]

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

Expand description

? formatting.

Debug should format the output in a programmer-facing, debugging context.

Generally speaking, you should just derive a Debug implementation.

When used with the alternate format specifier #?, the output is pretty-printed.

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

This trait can be used with #[derive] if all fields implement Debug. When derived for structs, it will use the name of the struct, then {, then a comma-separated list of each field’s name and Debug value, then }. For enums, it will use the name of the variant and, if applicable, (, then the Debug values of the fields, then ).

Stability

Derived Debug formats are not stable, and so may change with future Rust versions. Additionally, Debug implementations of types provided by the standard library (libstd, libcore, liballoc, etc.) are not stable, and may also change with future Rust versions.

Examples

Deriving an implementation:

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

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

assert_eq!(format!("The origin is: {:?}", origin), "The origin is: Point { x: 0, y: 0 }");

Run

Manually implementing:

use std::fmt;

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

impl fmt::Debug for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Point")
         .field("x", &self.x)
         .field("y", &self.y)
         .finish()
    }
}

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

assert_eq!(format!("The origin is: {:?}", origin), "The origin is: Point { x: 0, y: 0 }");

Run

There are a number of helper methods on the Formatter struct to help you with manual implementations, such as debug_struct.

Debug implementations using either derive or the debug builder API on Formatter support pretty-printing using the alternate flag: {:#?}.

Pretty-printing with #?:

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

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

assert_eq!(format!("The origin is: {:#?}", origin),
"The origin is: Point {
    x: 0,
    y: 0,
}");

Run

Required methods

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

Formats the value using the given formatter.

Examples

use std::fmt;

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

impl fmt::Debug for Position {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_tuple("")
         .field(&self.longitude)
         .field(&self.latitude)
         .finish()
    }
}

let position = Position { longitude: 1.987, latitude: 2.983 };
assert_eq!(format!("{:?}", position), "(1.987, 2.983)");

assert_eq!(format!("{:#?}", position), "(
    1.987,
    2.983,
)");

Run

Implementations on Foreign Types

`impl Debug for __m128d`[src]

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

`impl Debug for __m512`[src]

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

`impl Debug for __m128i`[src]

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

`impl Debug for __m128bh`[src]

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

`impl Debug for __m512d`[src]

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

`impl Debug for __m256bh`[src]

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

`impl Debug for __m128`[src]

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

`impl<'a> Debug for EscapeAscii<'a>`[src]

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

`impl<'a> Debug for Utf8LossyChunk<'a>`[src]

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

`impl Debug for __m512i`[src]

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

`impl Debug for __m256d`[src]

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

`impl<'_, T, P> Debug for SplitInclusive<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` [src]

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

`impl Debug for __m512bh`[src]

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

`impl Debug for __m256`[src]

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

`impl<'_, T, P> Debug for SplitInclusiveMut<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` [src]

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

`impl Debug for Utf8Lossy`[src]

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

`impl Debug for __m256i`[src]

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

`impl Debug for CpuidResult`[src]

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

Implementors

`impl Debug for BacktraceStatus`[src]

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

`impl Debug for std::cmp::Ordering`[src]

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

`impl Debug for TryReserveError`[src]

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

`impl Debug for Infallible`1.34.0[src]

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

`impl Debug for VarError`[src]

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

`impl Debug for c_void`1.16.0[src]

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

`impl Debug for ErrorKind`[src]

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

`impl Debug for SeekFrom`[src]

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

`impl Debug for IpAddr`1.7.0[src]

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

`impl Debug for Ipv6MulticastScope`[src]

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

`impl Debug for Shutdown`[src]

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

`impl Debug for std::net::SocketAddr`[src]

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

`impl Debug for FpCategory`[src]

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

`impl Debug for IntErrorKind`[src]

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

`impl Debug for AncillaryError`[src]

This is supported on (Android or DragonFly BSD or Emscripten or FreeBSD or Linux or NetBSD or OpenBSD) and Unix only.

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

`impl Debug for SearchStep`[src]

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

`impl Debug for std::sync::atomic::Ordering`[src]

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

`impl Debug for RecvTimeoutError`1.12.0[src]

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

`impl Debug for TryRecvError`[src]

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

`impl Debug for Alignment`1.28.0[src]

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

`impl Debug for bool`[src]

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

`impl Debug for char`[src]

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

`impl Debug for f32`[src]

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

`impl Debug for f64`[src]

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

`impl Debug for i8`[src]

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

`impl Debug for i16`[src]

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

`impl Debug for i32`[src]

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

`impl Debug for i64`[src]

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

`impl Debug for i128`[src]

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

`impl Debug for isize`[src]

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

`impl Debug for !`[src]

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

`impl Debug for str`[src]

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

`impl Debug for u8`[src]

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

`impl Debug for u16`[src]

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

`impl Debug for u32`[src]

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

`impl Debug for u64`[src]

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

`impl Debug for u128`[src]

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

`impl Debug for ()`[src]

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

`impl Debug for usize`[src]

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

`impl Debug for AllocError`[src]

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

`impl Debug for Global`[src]

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

`impl Debug for Layout`1.28.0[src]

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

`impl Debug for LayoutError`1.50.0[src]

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

`impl Debug for System`1.28.0[src]

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

`impl Debug for TypeId`[src]

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

`impl Debug for TryFromSliceError`1.34.0[src]

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

`impl Debug for std::ascii::EscapeDefault`1.16.0[src]

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

`impl Debug for Backtrace`[src]

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

`impl Debug for BacktraceFrame`[src]

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

`impl Debug for BorrowError`1.13.0[src]

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

`impl Debug for BorrowMutError`1.13.0[src]

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

`impl Debug for CharTryFromError`1.34.0[src]

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

`impl Debug for DecodeUtf16Error`1.9.0[src]

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

`impl Debug for std::char::EscapeDebug`1.20.0[src]

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

`impl Debug for std::char::EscapeDefault`[src]

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

`impl Debug for std::char::EscapeUnicode`[src]

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

`impl Debug for ParseCharError`1.20.0[src]

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

`impl Debug for ToLowercase`[src]

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

`impl Debug for ToUppercase`[src]

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

`impl Debug for DefaultHasher`1.13.0[src]

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

`impl Debug for RandomState`1.16.0[src]

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

`impl Debug for Args`1.16.0[src]

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

`impl Debug for ArgsOs`1.16.0[src]

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

`impl Debug for JoinPathsError`[src]

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

`impl Debug for SplitPaths<'_>`1.16.0[src]

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

`impl Debug for Vars`1.16.0[src]

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

`impl Debug for VarsOs`1.16.0[src]

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

`impl Debug for CStr`1.3.0[src]

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

`impl Debug for CString`[src]

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

`impl Debug for FromBytesWithNulError`1.10.0[src]

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

`impl Debug for FromVecWithNulError`[src]

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

`impl Debug for IntoStringError`1.7.0[src]

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

`impl Debug for NulError`[src]

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

`impl Debug for OsStr`[src]

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

`impl Debug for OsString`[src]

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

`impl Debug for DirBuilder`1.6.0[src]

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

`impl Debug for DirEntry`1.13.0[src]

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

`impl Debug for File`[src]

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

`impl Debug for FileType`1.1.0[src]

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

`impl Debug for Metadata`1.16.0[src]

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

`impl Debug for OpenOptions`[src]

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

`impl Debug for Permissions`[src]

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

`impl Debug for ReadDir`[src]

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

`impl Debug for SipHasher`[src]

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

`impl Debug for std::io::Empty`1.16.0[src]

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

`impl Debug for std::io::Error`[src]

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

`impl Debug for Initializer`[src]

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

`impl Debug for std::io::Repeat`1.16.0[src]

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

`impl Debug for Sink`1.16.0[src]

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

`impl Debug for Stderr`1.16.0[src]

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

`impl Debug for StderrLock<'_>`1.16.0[src]

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

`impl Debug for Stdin`1.16.0[src]

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

`impl Debug for StdinLock<'_>`1.16.0[src]

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

`impl Debug for Stdout`1.16.0[src]

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

`impl Debug for StdoutLock<'_>`1.16.0[src]

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

`impl Debug for PhantomPinned`1.33.0[src]

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

`impl Debug for AddrParseError`[src]

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

`impl Debug for Ipv4Addr`[src]

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

`impl Debug for Ipv6Addr`[src]

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

`impl Debug for SocketAddrV4`[src]

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

`impl Debug for SocketAddrV6`[src]

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

`impl Debug for TcpListener`[src]

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

`impl Debug for TcpStream`[src]

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

`impl Debug for UdpSocket`[src]

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

`impl Debug for NonZeroI8`1.34.0[src]

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

`impl Debug for NonZeroI16`1.34.0[src]

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

`impl Debug for NonZeroI32`1.34.0[src]

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

`impl Debug for NonZeroI64`1.34.0[src]

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

`impl Debug for NonZeroI128`1.34.0[src]

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

`impl Debug for NonZeroIsize`1.34.0[src]

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

`impl Debug for NonZeroU8`1.28.0[src]

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

`impl Debug for NonZeroU16`1.28.0[src]

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

`impl Debug for NonZeroU32`1.28.0[src]

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

`impl Debug for NonZeroU64`1.28.0[src]

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

`impl Debug for NonZeroU128`1.28.0[src]

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

`impl Debug for NonZeroUsize`1.28.0[src]

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

`impl Debug for ParseFloatError`[src]

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

`impl Debug for ParseIntError`[src]

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

`impl Debug for TryFromIntError`1.34.0[src]

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

`impl Debug for RangeFull`[src]

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

`impl Debug for std::os::unix::net::SocketAddr`1.10.0[src]

This is supported on Unix only.

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

`impl Debug for UCred`[src]

This is supported on Unix only.

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

`impl Debug for UnixDatagram`1.10.0[src]

This is supported on Unix only.

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

`impl Debug for UnixListener`1.10.0[src]

This is supported on Unix only.

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

`impl Debug for UnixStream`1.10.0[src]

This is supported on Unix only.

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

`impl Debug for Components<'_>`1.13.0[src]

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

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

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

`impl Debug for std::path::Iter<'_>`1.13.0[src]

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

`impl Debug for Path`[src]

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

`impl Debug for PathBuf`[src]

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

`impl Debug for StripPrefixError`1.7.0[src]

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

`impl Debug for Child`1.16.0[src]

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

`impl Debug for ChildStderr`1.16.0[src]

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

`impl Debug for ChildStdin`1.16.0[src]

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

`impl Debug for ChildStdout`1.16.0[src]

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

`impl Debug for Command`[src]

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

Format the program and arguments of a Command for display. Any non-utf8 data is lossily converted using the utf8 replacement character.

`impl Debug for ExitCode`[src]

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

`impl Debug for ExitStatus`[src]

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

`impl Debug for ExitStatusError`[src]

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

`impl Debug for Output`1.7.0[src]

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

`impl Debug for Stdio`1.16.0[src]

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

`impl Debug for ParseBoolError`[src]

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

`impl Debug for Utf8Error`[src]

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

`impl Debug for FromUtf8Error`[src]

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

`impl Debug for FromUtf16Error`[src]

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

`impl Debug for String`[src]

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

`impl Debug for AtomicBool`1.3.0[src]

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

`impl Debug for AtomicI8`1.34.0[src]

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

`impl Debug for AtomicI16`1.34.0[src]

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

`impl Debug for AtomicI32`1.34.0[src]

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

`impl Debug for AtomicI64`1.34.0[src]

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

`impl Debug for AtomicIsize`1.3.0[src]

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

`impl Debug for AtomicU8`1.34.0[src]

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

`impl Debug for AtomicU16`1.34.0[src]

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

`impl Debug for AtomicU32`1.34.0[src]

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

`impl Debug for AtomicU64`1.34.0[src]

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

`impl Debug for AtomicUsize`1.3.0[src]

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

`impl Debug for RecvError`[src]

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

`impl Debug for Barrier`1.16.0[src]

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

`impl Debug for BarrierWaitResult`1.16.0[src]

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

`impl Debug for Condvar`1.16.0[src]

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

`impl Debug for std::sync::Once`1.16.0[src]

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

`impl Debug for OnceState`1.51.0[src]

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

`impl Debug for WaitTimeoutResult`1.5.0[src]

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

`impl Debug for RawWaker`1.36.0[src]

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

`impl Debug for RawWakerVTable`1.36.0[src]

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

`impl Debug for Waker`1.36.0[src]

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

`impl Debug for AccessError`1.26.0[src]

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

`impl Debug for Builder`[src]

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

`impl Debug for Thread`[src]

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

`impl Debug for ThreadId`1.19.0[src]

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

`impl Debug for Duration`1.27.0[src]

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

`impl Debug for Instant`1.8.0[src]

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

`impl Debug for SystemTime`1.8.0[src]

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

`impl Debug for SystemTimeError`1.8.0[src]

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

`impl Debug for std::fmt::Error`[src]

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

`impl Debug for dyn Any + 'static`[src]

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

`impl Debug for dyn Any + 'static + Send`[src]

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

`impl Debug for dyn Any + 'static + Send + Sync`1.28.0[src]

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

`impl<'_> Debug for Chars<'_>`1.38.0[src]

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

`impl<'_> Debug for EncodeUtf16<'_>`1.17.0[src]

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

`impl<'_> Debug for std::string::Drain<'_>`1.17.0[src]

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

`impl<'_> Debug for Context<'_>`1.36.0[src]

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

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

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

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

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

`impl<'_, F> Debug for CharPredicateSearcher<'_, F> where F: FnMut(char) -> bool,` [src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::Entry<'_, K, V> where K: Debug + Ord, V: Debug,` 1.12.0[src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::Iter<'_, K, V> where K: Debug, V: Debug,` 1.17.0[src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::Keys<'_, K, V> where K: Debug,` 1.17.0[src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::OccupiedEntry<'_, K, V> where K: Debug + Ord, V: Debug,` 1.12.0[src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::OccupiedError<'_, K, V> where K: Debug + Ord, V: Debug,` [src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::Range<'_, K, V> where K: Debug, V: Debug,` 1.17.0[src]

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

`impl<'_, K, V> Debug for RangeMut<'_, K, V> where K: Debug, V: Debug,` 1.17.0[src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::VacantEntry<'_, K, V> where K: Debug + Ord,` 1.12.0[src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::Values<'_, K, V> where V: Debug,` 1.17.0[src]

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

`impl<'_, K, V> Debug for std::collections::btree_map::ValuesMut<'_, K, V> where V: Debug,` 1.10.0[src]

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

`impl<'_, K, V, F> Debug for std::collections::btree_map::DrainFilter<'_, K, V, F> where F: FnMut(&K, &mut V) -> bool, K: Debug, V: Debug,` [src]

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

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

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

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

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

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

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

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

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

`impl<'_, T> Debug for std::collections::binary_heap::Iter<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for PeekMut<'_, T> where T: Ord + Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::btree_set::Difference<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::btree_set::Intersection<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::btree_set::Iter<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::btree_set::SymmetricDifference<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::btree_set::Union<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::linked_list::Cursor<'_, T> where T: Debug,` [src]

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

`impl<'_, T> Debug for CursorMut<'_, T> where T: Debug,` [src]

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

`impl<'_, T> Debug for std::collections::linked_list::Iter<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::linked_list::IterMut<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::vec_deque::Drain<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::vec_deque::Iter<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::collections::vec_deque::IterMut<'_, T> where T: Debug,` 1.17.0[src]

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

`impl<'_, T> Debug for std::slice::Iter<'_, T> where T: Debug,` 1.9.0[src]

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

`impl<'_, T> Debug for std::slice::IterMut<'_, T> where T: Debug,` 1.9.0[src]

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

`impl<'_, T, A> Debug for std::vec::Drain<'_, T, A> where T: Debug, A: Allocator,` 1.17.0[src]

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

`impl<'_, T, F> Debug for std::collections::btree_set::DrainFilter<'_, T, F> where F: FnMut(&T) -> bool, T: Debug,` [src]

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

`impl<'_, T, F> Debug for std::collections::linked_list::DrainFilter<'_, T, F> where F: FnMut(&mut T) -> bool, T: Debug,` [src]

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

`impl<'_, T, P> Debug for std::slice::RSplit<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` 1.27.0[src]

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

`impl<'_, T, P> Debug for RSplitMut<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` 1.27.0[src]

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

`impl<'_, T, P> Debug for std::slice::RSplitN<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` 1.9.0[src]

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

`impl<'_, T, P> Debug for RSplitNMut<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` 1.9.0[src]

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

`impl<'_, T, P> Debug for std::slice::Split<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` 1.9.0[src]

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

`impl<'_, T, P> Debug for SplitMut<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` 1.9.0[src]

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

`impl<'_, T, P> Debug for std::slice::SplitN<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` 1.9.0[src]

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

`impl<'_, T, P> Debug for SplitNMut<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` 1.9.0[src]

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

`impl<'a> Debug for Component<'a>`[src]

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

`impl<'a> Debug for Prefix<'a>`[src]

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

`impl<'a> Debug for std::error::Chain<'a>`[src]

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

`impl<'a> Debug for IoSlice<'a>`1.36.0[src]

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

`impl<'a> Debug for IoSliceMut<'a>`1.36.0[src]

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

`impl<'a> Debug for std::net::Incoming<'a>`[src]

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

`impl<'a> Debug for std::os::unix::net::Incoming<'a>`1.10.0[src]

This is supported on Unix only.

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

`impl<'a> Debug for SocketAncillary<'a>`[src]

This is supported on (Android or DragonFly BSD or Emscripten or FreeBSD or Linux or NetBSD or OpenBSD) and Unix only.

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

`impl<'a> Debug for Location<'a>`1.10.0[src]

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

`impl<'a> Debug for PanicInfo<'a>`1.10.0[src]

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

`impl<'a> Debug for Ancestors<'a>`1.28.0[src]

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

`impl<'a> Debug for PrefixComponent<'a>`[src]

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

`impl<'a> Debug for CommandArgs<'a>`[src]

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

`impl<'a> Debug for CommandEnvs<'a>`[src]

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

`impl<'a> Debug for CharSearcher<'a>`[src]

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

`impl<'a> Debug for std::str::Bytes<'a>`[src]

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

`impl<'a> Debug for CharIndices<'a>`[src]

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

`impl<'a> Debug for std::str::EscapeDebug<'a>`1.34.0[src]

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

`impl<'a> Debug for std::str::EscapeDefault<'a>`1.34.0[src]

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

`impl<'a> Debug for std::str::EscapeUnicode<'a>`1.34.0[src]

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

`impl<'a> Debug for std::str::Lines<'a>`[src]

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

`impl<'a> Debug for LinesAny<'a>`[src]

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

`impl<'a> Debug for SplitAsciiWhitespace<'a>`1.34.0[src]

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

`impl<'a> Debug for SplitWhitespace<'a>`1.1.0[src]

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

`impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>`[src]

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

`impl<'a, 'b> Debug for StrSearcher<'a, 'b>`[src]

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

`impl<'a, 'f> Debug for VaList<'a, 'f> where 'f: 'a,` [src]

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

`impl<'a, A> Debug for std::option::Iter<'a, A> where A: 'a + Debug,` [src]

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

`impl<'a, A> Debug for std::option::IterMut<'a, A> where A: 'a + Debug,` [src]

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

`impl<'a, I, A> Debug for Splice<'a, I, A> where I: 'a + Debug + Iterator, A: 'a + Debug + Allocator, ::Item: Debug,` 1.21.0[src]

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

`impl<'a, K, F> Debug for std::collections::hash_set::DrainFilter<'a, K, F> where F: FnMut(&K) -> bool,` [src]

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

`impl<'a, K, V> Debug for std::collections::btree_map::IterMut<'a, K, V> where K: 'a + Debug, V: 'a + Debug,` [src]

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

`impl<'a, K, V, F> Debug for std::collections::hash_map::DrainFilter<'a, K, V, F> where F: FnMut(&K, &mut V) -> bool,` [src]

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

`impl<'a, P> Debug for MatchIndices<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` 1.5.0[src]

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

`impl<'a, P> Debug for Matches<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` 1.2.0[src]

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

`impl<'a, P> Debug for RMatchIndices<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` 1.5.0[src]

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

`impl<'a, P> Debug for RMatches<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` 1.2.0[src]

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

`impl<'a, P> Debug for std::str::RSplit<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` [src]

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

`impl<'a, P> Debug for std::str::RSplitN<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` [src]

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

`impl<'a, P> Debug for RSplitTerminator<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` [src]

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

`impl<'a, P> Debug for std::str::Split<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` [src]

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

`impl<'a, P> Debug for std::str::SplitInclusive<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` 1.51.0[src]

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

`impl<'a, P> Debug for std::str::SplitN<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` [src]

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

`impl<'a, P> Debug for SplitTerminator<'a, P> where P: Pattern<'a>, >::Searcher: Debug,` [src]

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

`impl<'a, T> Debug for std::collections::binary_heap::Drain<'a, T> where T: 'a + Debug,` 1.6.0[src]

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

`impl<'a, T> Debug for DrainSorted<'a, T> where T: Debug + Ord,` [src]

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

`impl<'a, T> Debug for std::collections::btree_set::Range<'a, T> where T: 'a + Debug,` 1.17.0[src]

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

`impl<'a, T> Debug for std::result::Iter<'a, T> where T: 'a + Debug,` [src]

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

`impl<'a, T> Debug for std::result::IterMut<'a, T> where T: 'a + Debug,` [src]

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

`impl<'a, T> Debug for Chunks<'a, T> where T: 'a + Debug,` [src]

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

`impl<'a, T> Debug for ChunksExact<'a, T> where T: 'a + Debug,` 1.31.0[src]

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

`impl<'a, T> Debug for ChunksExactMut<'a, T> where T: 'a + Debug,` 1.31.0[src]

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

`impl<'a, T> Debug for ChunksMut<'a, T> where T: 'a + Debug,` [src]

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

`impl<'a, T> Debug for RChunks<'a, T> where T: 'a + Debug,` 1.31.0[src]

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

`impl<'a, T> Debug for RChunksExact<'a, T> where T: 'a + Debug,` 1.31.0[src]

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

`impl<'a, T> Debug for RChunksExactMut<'a, T> where T: 'a + Debug,` 1.31.0[src]

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

`impl<'a, T> Debug for RChunksMut<'a, T> where T: 'a + Debug,` 1.31.0[src]

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

`impl<'a, T> Debug for Windows<'a, T> where T: 'a + Debug,` [src]

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

`impl<'a, T, F, A> Debug for std::vec::DrainFilter<'a, T, F, A> where F: Debug + FnMut(&mut T) -> bool, T: Debug, A: Debug + Allocator,` [src]

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

`impl<'a, T, P> Debug for GroupBy<'a, T, P> where T: 'a + Debug,` [src]

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

`impl<'a, T, P> Debug for GroupByMut<'a, T, P> where T: 'a + Debug,` [src]

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

`impl<'a, T, const N: usize> Debug for ArrayChunks<'a, T, N> where T: 'a + Debug,` [src]

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

`impl<'a, T, const N: usize> Debug for ArrayChunksMut<'a, T, N> where T: 'a + Debug,` [src]

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

`impl<'a, T, const N: usize> Debug for ArrayWindows<'a, T, N> where T: 'a + Debug,` [src]

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

`impl<'a, T: Debug + 'a> Debug for std::sync::mpsc::Iter<'a, T>`[src]

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

`impl<'a, T: Debug + 'a> Debug for TryIter<'a, T>`1.15.0[src]

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

`impl<'f> Debug for VaListImpl<'f>`[src]

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

`impl<A> Debug for std::iter::Repeat<A> where A: Debug,` [src]

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

`impl<A> Debug for std::option::IntoIter<A> where A: Debug,` [src]

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

`impl<A, B> Debug for std::iter::Chain<A, B> where B: Debug, A: Debug,` [src]

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

`impl<A, B> Debug for Zip<A, B> where B: Debug, A: Debug,` [src]

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

`impl<B, C> Debug for ControlFlow<B, C> where C: Debug, B: Debug,` [src]

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

`impl<B: Debug> Debug for std::io::Lines`[src]

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

`impl<B: Debug> Debug for std::io::Split`[src]

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

`impl<Dyn> Debug for DynMetadata<Dyn> where Dyn: ?Sized,` [src]

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

`impl<F> Debug for PollFn<F>`[src]

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

`impl<F> Debug for FromFn<F>`1.34.0[src]

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

`impl<F> Debug for OnceWith<F> where F: Debug,` 1.43.0[src]

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

`impl<F> Debug for RepeatWith<F> where F: Debug,` 1.28.0[src]

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

`impl<H> Debug for BuildHasherDefault<H>`1.9.0[src]

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

`impl Debug for DecodeUtf16 where I: Debug + Iterator<Item = u16>,` 1.9.0[src]

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

`impl Debug for Cloned where I: Debug,` 1.1.0[src]

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

`impl Debug for Copied where I: Debug,` 1.36.0[src]

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

`impl Debug for Cycle where I: Debug,` [src]

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

`impl Debug for Enumerate where I: Debug,` [src]

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

`impl Debug for Fuse where I: Debug,` [src]

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

`impl Debug for Intersperse where I: Debug + Iterator, ::Item: Clone, ::Item: Debug,` [src]

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

`impl Debug for Peekable where I: Debug + Iterator, ::Item: Debug,` [src]

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

`impl Debug for Skip where I: Debug,` [src]

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

`impl Debug for StepBy where I: Debug,` 1.28.0[src]

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

`impl Debug for std::iter::Take where I: Debug,` [src]

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

`impl<I, F> Debug for FilterMap<I, F> where I: Debug,` 1.9.0[src]

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

`impl<I, F> Debug for Inspect<I, F> where I: Debug,` 1.9.0[src]

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

`impl<I, F> Debug for Map<I, F> where I: Debug,` 1.9.0[src]

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

`impl<I, G> Debug for IntersperseWith<I, G> where I: Iterator + Debug, G: Debug, ::Item: Debug,` [src]

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

`impl<I, P> Debug for Filter<I, P> where I: Debug,` 1.9.0[src]

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

`impl<I, P> Debug for MapWhile<I, P> where I: Debug,` [src]

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

`impl<I, P> Debug for SkipWhile<I, P> where I: Debug,` 1.9.0[src]

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

`impl<I, P> Debug for TakeWhile<I, P> where I: Debug,` 1.9.0[src]

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

`impl<I, St, F> Debug for Scan<I, St, F> where I: Debug, St: Debug,` 1.9.0[src]

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

`impl<I, U> Debug for Flatten where I: Debug + Iterator, U: Debug + Iterator, ::Item: IntoIterator, <::Item as IntoIterator>::IntoIter == U, <::Item as IntoIterator>::Item == ::Item,` 1.29.0[src]

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

`impl<I, U, F> Debug for FlatMap<I, U, F> where I: Debug, U: IntoIterator, ::IntoIter: Debug,` 1.9.0[src]

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

`impl<Idx> Debug for std::ops::Range<Idx> where Idx: Debug,` [src]

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

`impl<Idx> Debug for RangeFrom<Idx> where Idx: Debug,` [src]

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

`impl<Idx> Debug for RangeInclusive<Idx> where Idx: Debug,` 1.26.0[src]

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

`impl<Idx> Debug for RangeTo<Idx> where Idx: Debug,` [src]

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

`impl<Idx> Debug for RangeToInclusive<Idx> where Idx: Debug,` 1.26.0[src]

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

`impl<K, V> Debug for std::collections::btree_map::IntoIter<K, V> where K: Debug, V: Debug,` 1.17.0[src]

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

`impl<K, V> Debug for std::collections::btree_map::IntoKeys<K, V> where K: Debug,` 1.54.0[src]

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

`impl<K, V> Debug for std::collections::btree_map::IntoValues<K, V> where V: Debug,` 1.54.0[src]

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

`impl<K, V> Debug for std::collections::hash_map::Drain<'_, K, V> where K: Debug, V: Debug,` 1.16.0[src]

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

`impl<K, V> Debug for std::collections::hash_map::IterMut<'_, K, V> where K: Debug, V: Debug,` 1.16.0[src]

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

`impl<K, V> Debug for BTreeMap<K, V> where K: Debug, V: Debug,` [src]

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

`impl<K, V, S> Debug for HashMap<K, V, S> where K: Debug, V: Debug,` [src]

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

`impl<K, V, S> Debug for RawEntryBuilder<'_, K, V, S>`[src]

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

`impl<K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>`[src]

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

`impl<K, V, S> Debug for RawVacantEntryMut<'_, K, V, S>`[src]

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

`impl<K, V: Debug> Debug for std::collections::hash_map::IntoValues<K, V>`1.54.0[src]

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

`impl<K, V: Debug> Debug for std::collections::hash_map::Values<'_, K, V>`1.16.0[src]

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

`impl<K, V: Debug> Debug for std::collections::hash_map::ValuesMut<'_, K, V>`1.16.0[src]

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

`impl<K: Debug> Debug for std::collections::hash_set::Drain<'_, K>`1.16.0[src]

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

`impl<K: Debug> Debug for std::collections::hash_set::IntoIter<K>`1.16.0[src]

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

`impl<K: Debug> Debug for std::collections::hash_set::Iter<'_, K>`1.16.0[src]

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

`impl<K: Debug, V> Debug for std::collections::hash_map::IntoKeys<K, V>`1.54.0[src]

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

`impl<K: Debug, V> Debug for std::collections::hash_map::Keys<'_, K, V>`1.16.0[src]

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

`impl<K: Debug, V> Debug for std::collections::hash_map::VacantEntry<'_, K, V>`1.12.0[src]

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

`impl<K: Debug, V: Debug> Debug for std::collections::hash_map::Entry<'_, K, V>`1.12.0[src]

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

`impl<K: Debug, V: Debug> Debug for std::collections::hash_map::IntoIter<K, V>`1.16.0[src]

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

`impl<K: Debug, V: Debug> Debug for std::collections::hash_map::Iter<'_, K, V>`1.16.0[src]

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

`impl<K: Debug, V: Debug> Debug for std::collections::hash_map::OccupiedEntry<'_, K, V>`1.12.0[src]

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

`impl<K: Debug, V: Debug> Debug for std::collections::hash_map::OccupiedError<'_, K, V>`[src]

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

`impl<K: Debug, V: Debug, S> Debug for RawEntryMut<'_, K, V, S>`[src]

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

`impl<K: Debug, V: Debug, S> Debug for RawOccupiedEntryMut<'_, K, V, S>`[src]

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

`impl Debug for Pin where P: Debug,` 1.33.0[src]

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

`impl<R> Debug for BufReader<R> where R: Debug,` [src]

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

`impl<R: Debug> Debug for std::io::Bytes<R>`[src]

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

`impl<Ret> Debug for fn() -> Ret`1.4.0[src]

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

`impl<Ret> Debug for extern "C" fn() -> Ret`1.4.0[src]

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

`impl<Ret> Debug for unsafe fn() -> Ret`1.4.0[src]

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

`impl<Ret> Debug for unsafe extern "C" fn() -> Ret`1.4.0[src]

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

`impl<Ret, A> Debug for fn(A) -> Ret`1.4.0[src]

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

`impl<Ret, A> Debug for extern "C" fn(A) -> Ret`1.4.0[src]

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

`impl<Ret, A> Debug for extern "C" fn(A, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A> Debug for unsafe fn(A) -> Ret`1.4.0[src]

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

`impl<Ret, A> Debug for unsafe extern "C" fn(A) -> Ret`1.4.0[src]

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

`impl<Ret, A> Debug for unsafe extern "C" fn(A, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B> Debug for fn(A, B) -> Ret`1.4.0[src]

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

`impl<Ret, A, B> Debug for extern "C" fn(A, B) -> Ret`1.4.0[src]

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

`impl<Ret, A, B> Debug for extern "C" fn(A, B, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B> Debug for unsafe fn(A, B) -> Ret`1.4.0[src]

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

`impl<Ret, A, B> Debug for unsafe extern "C" fn(A, B) -> Ret`1.4.0[src]

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

`impl<Ret, A, B> Debug for unsafe extern "C" fn(A, B, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C> Debug for fn(A, B, C) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C> Debug for unsafe fn(A, B, C) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C> Debug for unsafe extern "C" fn(A, B, C) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C> Debug for unsafe extern "C" fn(A, B, C, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D> Debug for fn(A, B, C, D) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D> Debug for unsafe fn(A, B, C, D) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D> Debug for unsafe extern "C" fn(A, B, C, D) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D> Debug for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E> Debug for fn(A, B, C, D, E) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E> Debug for unsafe fn(A, B, C, D, E) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F> Debug for fn(A, B, C, D, E, F) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F> Debug for unsafe fn(A, B, C, D, E, F) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F> Debug for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F> Debug for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G> Debug for fn(A, B, C, D, E, F, G) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G> Debug for extern "C" fn(A, B, C, D, E, F, G) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G> Debug for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G> Debug for unsafe fn(A, B, C, D, E, F, G) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H> Debug for fn(A, B, C, D, E, F, G, H) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H> Debug for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for fn(A, B, C, D, E, F, G, H, I) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`1.4.0[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`1.4.0[src]

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

`impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where T0: Debug, T1: Debug, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where T1: Debug, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T3, T4, T5, T6, T7, T8, T9, T10, T11) where T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T4, T5, T6, T7, T8, T9, T10, T11) where T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T5, T6, T7, T8, T9, T10, T11> Debug for (T5, T6, T7, T8, T9, T10, T11) where T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T6, T7, T8, T9, T10, T11> Debug for (T6, T7, T8, T9, T10, T11) where T6: Debug, T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T7, T8, T9, T10, T11> Debug for (T7, T8, T9, T10, T11) where T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T8, T9, T10, T11> Debug for (T8, T9, T10, T11) where T8: Debug, T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T9, T10, T11> Debug for (T9, T10, T11) where T9: Debug, T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T10, T11> Debug for (T10, T11) where T10: Debug, T11: Debug + ?Sized,` [src]

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

`impl<T11> Debug for (T11,) where T11: Debug + ?Sized,` [src]

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

`impl<T> Debug for Bound<T> where T: Debug,` 1.17.0[src]

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

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

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

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

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

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

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

`impl<T> Debug for Poll<T> where T: Debug,` 1.36.0[src]

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

`impl<T> Debug for *const T where T: ?Sized,` [src]

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

`impl<T> Debug for *mut T where T: ?Sized,` [src]

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

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

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

`impl<T> Debug for Cell<T> where T: Copy + Debug,` [src]

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

`impl<T> Debug for RefCell<T> where T: Debug + ?Sized,` [src]

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

`impl<T> Debug for UnsafeCell<T> where T: ?Sized,` 1.9.0[src]

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

`impl<T> Debug for Reverse<T> where T: Debug,` 1.19.0[src]

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

`impl<T> Debug for std::collections::binary_heap::IntoIter<T> where T: Debug,` 1.17.0[src]

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

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

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

`impl<T> Debug for std::collections::btree_set::IntoIter<T> where T: Debug,` [src]

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

`impl<T> Debug for std::collections::linked_list::IntoIter<T> where T: Debug,` 1.17.0[src]

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

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

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

`impl<T> Debug for BinaryHeap<T> where T: Debug,` 1.4.0[src]

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

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

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

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

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

`impl<T> Debug for std::collections::vec_deque::IntoIter<T> where T: Debug,` 1.17.0[src]

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

`impl<T> Debug for Pending<T>`1.48.0[src]

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

`impl<T> Debug for Ready<T> where T: Debug,` 1.48.0[src]

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

`impl<T> Debug for std::iter::Empty<T>`1.9.0[src]

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

`impl<T> Debug for std::iter::Once<T> where T: Debug,` 1.2.0[src]

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

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

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

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

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

`impl<T> Debug for PhantomData<T> where T: ?Sized,` [src]

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

`impl<T> Debug for Discriminant<T>`1.21.0[src]

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

`impl<T> Debug for ManuallyDrop<T> where T: Debug + ?Sized,` 1.20.0[src]

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

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

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

`impl<T> Debug for NonNull<T> where T: ?Sized,` 1.25.0[src]

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

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

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

`impl<T> Debug for std::rc::Weak<T> where T: Debug + ?Sized,` 1.4.0[src]

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

`impl<T> Debug for std::result::IntoIter<T> where T: Debug,` [src]

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

`impl<T> Debug for AtomicPtr<T>`1.3.0[src]

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

`impl<T> Debug for Receiver<T>`1.8.0[src]

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

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

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

`impl<T> Debug for Sender<T>`1.8.0[src]

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

`impl<T> Debug for SyncSender<T>`1.8.0[src]

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

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

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

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

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

`impl<T> Debug for std::sync::Weak<T> where T: Debug + ?Sized,` 1.4.0[src]

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

`impl<T> Debug for JoinHandle<T>`1.16.0[src]

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

`impl<T> Debug for MaybeUninit<T>`1.41.0[src]

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

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

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

`impl<T, A> Debug for std::vec::IntoIter<T, A> where T: Debug, A: Allocator,` 1.13.0[src]

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

`impl<T, A> Debug for Vec<T, A> where T: Debug, A: Allocator,` [src]

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

`impl<T, E> Debug for Result<T, E> where T: Debug, E: Debug,` [src]

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

`impl<T, F> Debug for Successors<T, F> where T: Debug,` 1.34.0[src]

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

`impl<T, F> Debug for Lazy<T, F> where T: Debug,` [src]

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

`impl<T, S> Debug for std::collections::hash_set::Difference<'_, T, S> where T: Debug + Eq + Hash, S: BuildHasher,` 1.16.0[src]

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

`impl<T, S> Debug for HashSet<T, S> where T: Debug,` [src]

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

`impl<T, S> Debug for std::collections::hash_set::Intersection<'_, T, S> where T: Debug + Eq + Hash, S: BuildHasher,` 1.16.0[src]

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

`impl<T, S> Debug for std::collections::hash_set::SymmetricDifference<'_, T, S> where T: Debug + Eq + Hash, S: BuildHasher,` 1.16.0[src]

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

`impl<T, S> Debug for std::collections::hash_set::Union<'_, T, S> where T: Debug + Eq + Hash, S: BuildHasher,` 1.16.0[src]

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

`impl<T, const N: usize> Debug for [T; N] where T: Debug,` [src]

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

`impl<T, const N: usize> Debug for std::array::IntoIter<T, N> where T: Debug,` 1.40.0[src]

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

`impl<T: 'static> Debug for LocalKey<T>`1.16.0[src]

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

`impl<T: Debug> Debug for std::io::Cursor<T>`[src]

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

`impl<T: Debug> Debug for std::io::Take<T>`[src]

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

`impl<T: Debug> Debug for SyncOnceCell<T>`[src]

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

`impl<T: Debug> Debug for AssertUnwindSafe<T>`1.16.0[src]

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

`impl<T: Debug> Debug for std::sync::mpsc::IntoIter<T>`1.1.0[src]

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

`impl<T: Debug> Debug for RwLockReadGuard<'_, T>`1.16.0[src]

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

`impl<T: Debug> Debug for RwLockWriteGuard<'_, T>`1.16.0[src]

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

`impl<T: Debug, F> Debug for SyncLazy<T, F>`[src]

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

`impl<T: Debug, U: Debug> Debug for std::io::Chain<T, U>`[src]

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

`impl<T: ?Sized + Debug> Debug for Mutex<T>`[src]

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

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

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

`impl<T: ?Sized + Debug> Debug for RwLock<T>`[src]

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

`impl<W: Write> Debug for BufWriter<W> where W: Debug,` [src]

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

`impl<W: Write> Debug for LineWriter<W> where W: Debug,` [src]

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

`impl<W: Debug> Debug for IntoInnerError<W>`[src]

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

`impl<Y, R> Debug for GeneratorState<Y, R> where R: Debug, Y: Debug,` [src]

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

Trait std::fmt::Debug1.0.0[−][src]

Stability

Examples

Required methods

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

Examples

Implementations on Foreign Types

impl Debug for __m128d[src]

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

impl Debug for __m512[src]

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

impl Debug for __m128i[src]

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

impl Debug for __m128bh[src]

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

impl Debug for __m512d[src]

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

impl Debug for __m256bh[src]

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

impl Debug for __m128[src]

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

impl<'a> Debug for EscapeAscii<'a>[src]

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

impl<'a> Debug for Utf8LossyChunk<'a>[src]

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

impl Debug for __m512i[src]

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

impl Debug for __m256d[src]

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

impl<'_, T, P> Debug for SplitInclusive<'_, T, P> where T: Debug, P: FnMut(&T) -> bool, [src]

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

impl Debug for __m512bh[src]

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

impl Debug for __m256[src]

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

impl<'_, T, P> Debug for SplitInclusiveMut<'_, T, P> where T: Debug, P: FnMut(&T) -> bool, [src]

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

impl Debug for Utf8Lossy[src]

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

impl Debug for __m256i[src]

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

impl Debug for CpuidResult[src]

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

Implementors

impl Debug for BacktraceStatus[src]

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

impl Debug for std::cmp::Ordering[src]

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

impl Debug for TryReserveError[src]

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

impl Debug for Infallible1.34.0[src]

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

impl Debug for VarError[src]

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

impl Debug for c_void1.16.0[src]

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

impl Debug for ErrorKind[src]

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

impl Debug for SeekFrom[src]

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

impl Debug for IpAddr1.7.0[src]

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

impl Debug for Ipv6MulticastScope[src]

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

impl Debug for Shutdown[src]

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

impl Debug for std::net::SocketAddr[src]

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

impl Debug for FpCategory[src]

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

impl Debug for IntErrorKind[src]

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

impl Debug for AncillaryError[src]

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

impl Debug for SearchStep[src]

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

impl Debug for std::sync::atomic::Ordering[src]

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

impl Debug for RecvTimeoutError1.12.0[src]

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

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

`impl Debug for __m128d`[src]

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

`impl Debug for __m512`[src]

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

`impl Debug for __m128i`[src]

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

`impl Debug for __m128bh`[src]

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

`impl Debug for __m512d`[src]

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

`impl Debug for __m256bh`[src]

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

`impl Debug for __m128`[src]

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

`impl<'a> Debug for EscapeAscii<'a>`[src]

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

`impl<'a> Debug for Utf8LossyChunk<'a>`[src]

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

`impl Debug for __m512i`[src]

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

`impl Debug for __m256d`[src]

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

`impl<'_, T, P> Debug for SplitInclusive<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` [src]

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

`impl Debug for __m512bh`[src]

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

`impl Debug for __m256`[src]

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

`impl<'_, T, P> Debug for SplitInclusiveMut<'_, T, P> where T: Debug, P: FnMut(&T) -> bool,` [src]

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

`impl Debug for Utf8Lossy`[src]

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

`impl Debug for __m256i`[src]

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

`impl Debug for CpuidResult`[src]

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

`impl Debug for BacktraceStatus`[src]

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

`impl Debug for std::cmp::Ordering`[src]

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

`impl Debug for TryReserveError`[src]

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

`impl Debug for Infallible`1.34.0[src]

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

`impl Debug for VarError`[src]

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

`impl Debug for c_void`1.16.0[src]

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

`impl Debug for ErrorKind`[src]

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

`impl Debug for SeekFrom`[src]

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

`impl Debug for IpAddr`1.7.0[src]

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

`impl Debug for Ipv6MulticastScope`[src]

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

`impl Debug for Shutdown`[src]

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

`impl Debug for std::net::SocketAddr`[src]

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

`impl Debug for FpCategory`[src]

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

`impl Debug for IntErrorKind`[src]

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

`impl Debug for AncillaryError`[src]

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

`impl Debug for SearchStep`[src]

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

`impl Debug for std::sync::atomic::Ordering`[src]

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

`impl Debug for RecvTimeoutError`1.12.0[src]

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

`impl Debug for TryRecvError`[src]

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

`impl Debug for Alignment`1.28.0[src]

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

`impl Debug for bool`[src]

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

`impl Debug for char`[src]