W3cubDocs

/Rust

Trait std::fmt::Debug

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

? 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 }");

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 }");

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,
}");

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::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,
)");

Loading content...

Implementations on Foreign Types

`impl Debug for __m512`[src]

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

`impl Debug for __m256d`[src]

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

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

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

`impl Debug for __m64`[src]

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

`impl Debug for __m256`[src]

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

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

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

`impl Debug for __m512d`[src]

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

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

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

`impl Debug for __m128`[src]

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

`impl Debug for CpuidResult`[src]

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

`impl Debug for Utf8Lossy`[src]

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

`impl Debug for __m128d`[src]

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

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

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

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

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

`impl Debug for __m512i`[src]

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

`impl Debug for __m256i`[src]

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

`impl Debug for __m128i`[src]

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

Loading content...

Implementors

`impl Debug for BacktraceStatus`[src]

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

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

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

`impl Debug for TryReserveError`[src]

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

`impl Debug for Infallible`[src]

`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`[src]

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

`impl Debug for Alignment`[src]

`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`[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]

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

`impl Debug for IntErrorKind`[src]

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

`impl Debug for SearchStep`[src]

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

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

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

`impl Debug for RecvTimeoutError`[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 bool`[src]

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

`impl Debug for char`[src]

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

`impl Debug for f32`[src]

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

`impl Debug for f64`[src]

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

`impl Debug for i8`[src]

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

`impl Debug for i16`[src]

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

`impl Debug for i32`[src]

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

`impl Debug for i64`[src]

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

`impl Debug for i128`[src]

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

`impl Debug for isize`[src]

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

`impl Debug for !`[src]

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

`impl Debug for str`[src]

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

`impl Debug for u8`[src]

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

`impl Debug for u16`[src]

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

`impl Debug for u32`[src]

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

`impl Debug for u64`[src]

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

`impl Debug for u128`[src]

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

`impl Debug for ()`[src]

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

`impl Debug for usize`[src]

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

`impl Debug for AllocErr`[src]

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

`impl Debug for Global`[src]

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

`impl Debug for Layout`[src]

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

`impl Debug for LayoutErr`[src]

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

`impl Debug for System`[src]

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

`impl Debug for TypeId`[src]

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

`impl Debug for TryFromSliceError`[src]

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

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

`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 BorrowError`[src]

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

`impl Debug for BorrowMutError`[src]

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

`impl Debug for CharTryFromError`[src]

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

`impl Debug for DecodeUtf16Error`[src]

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

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

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

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

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

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

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

`impl Debug for ParseCharError`[src]

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

`impl Debug for ToLowercase`[src]

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

`impl Debug for ToUppercase`[src]

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

`impl Debug for DefaultHasher`[src]

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

`impl Debug for RandomState`[src]

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

`impl Debug for Args`[src]

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

`impl Debug for ArgsOs`[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 Vars`[src]

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

`impl Debug for VarsOs`[src]

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

`impl Debug for CStr`[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`[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`[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 std::fmt::Error`[src]

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

`impl Debug for DirBuilder`[src]

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

`impl Debug for DirEntry`[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`[src]

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

`impl Debug for Metadata`[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]

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

`impl Debug for std::io::Empty`[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`[src]

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

`impl Debug for Sink`[src]

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

`impl Debug for Stderr`[src]

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

`impl Debug for Stdin`[src]

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

`impl Debug for Stdout`[src]

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

`impl Debug for PhantomPinned`[src]

`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`[src]

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

`impl Debug for NonZeroI16`[src]

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

`impl Debug for NonZeroI32`[src]

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

`impl Debug for NonZeroI64`[src]

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

`impl Debug for NonZeroI128`[src]

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

`impl Debug for NonZeroIsize`[src]

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

`impl Debug for NonZeroU8`[src]

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

`impl Debug for NonZeroU16`[src]

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

`impl Debug for NonZeroU32`[src]

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

`impl Debug for NonZeroU64`[src]

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

`impl Debug for NonZeroU128`[src]

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

`impl Debug for NonZeroUsize`[src]

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

`impl Debug for ParseFloatError`[src]

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

`impl Debug for ParseIntError`[src]

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

`impl Debug for TryFromIntError`[src]

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

`impl Debug for RangeFull`[src]

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

`impl Debug for NoneError`[src]

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

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

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

`impl Debug for UnixDatagram`[src]

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

`impl Debug for UnixListener`[src]

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

`impl Debug for UnixStream`[src]

`fn fmt(&self, fmt: &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`[src]

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

`impl Debug for Child`[src]

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

`impl Debug for ChildStderr`[src]

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

`impl Debug for ChildStdin`[src]

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

`impl Debug for ChildStdout`[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 Output`[src]

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

`impl Debug for Stdio`[src]

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

`impl Debug for ParseBoolError`[src]

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

`impl Debug for Utf8Error`[src]

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

`impl Debug for FromUtf8Error`[src]

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

`impl Debug for FromUtf16Error`[src]

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

`impl Debug for String`[src]

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

`impl Debug for AtomicBool`[src]

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

`impl Debug for AtomicI8`[src]

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

`impl Debug for AtomicI16`[src]

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

`impl Debug for AtomicI32`[src]

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

`impl Debug for AtomicI64`[src]

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

`impl Debug for AtomicIsize`[src]

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

`impl Debug for AtomicU8`[src]

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

`impl Debug for AtomicU16`[src]

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

`impl Debug for AtomicU32`[src]

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

`impl Debug for AtomicU64`[src]

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

`impl Debug for AtomicUsize`[src]

`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`[src]

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

`impl Debug for BarrierWaitResult`[src]

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

`impl Debug for Condvar`[src]

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

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

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

`impl Debug for OnceState`[src]

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

`impl Debug for WaitTimeoutResult`[src]

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

`impl Debug for RawWaker`[src]

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

`impl Debug for RawWakerVTable`[src]

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

`impl Debug for Waker`[src]

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

`impl Debug for AccessError`[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`[src]

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

`impl Debug for Duration`[src]

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

`impl Debug for Instant`[src]

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

`impl Debug for SystemTime`[src]

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

`impl Debug for SystemTimeError`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<'_> Debug for Components<'_>`[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<'_>`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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,` [src]

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

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

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

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

`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,` [src]

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

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

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

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

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

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

`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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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]

`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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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>`[src]

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

`impl<'a> Debug for IoSliceMut<'a>`[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>`[src]

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

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

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

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

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

`impl<'a> Debug for Ancestors<'a>`[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 CharSearcher<'a>`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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]

`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]

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

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

`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]

`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]

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

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

`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,` [src]

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

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

`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,` [src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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]

`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>`[src]

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

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

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

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

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

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

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

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

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

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

`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<F> Debug for FromFn<F>`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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,` [src]

`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,` [src]

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

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

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

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

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

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

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

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

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

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

`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,` [src]

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

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

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

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

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

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

`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,` [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,` [src]

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

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

`fn fmt(&self, f: &mut Formatter<'_>) -> Result`[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::Values<'_, K, V>`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<K: Debug, V: Debug, '_> Debug for RawOccupiedEntryMut<'_, 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 Debug for Pin where P: Debug,` [src]

`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`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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`[src]

`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`[src]

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

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

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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`[src]

`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, T10: Debug, T11: Debug + ?Sized, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug,` [src]

`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, T10: Debug, T11: Debug + ?Sized, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug,` [src]

`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 T10: Debug, T11: Debug + ?Sized, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug,` [src]

`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 T10: Debug, T11: Debug + ?Sized, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug,` [src]

`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 T10: Debug, T11: Debug + ?Sized, T4: Debug, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug,` [src]

`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 T10: Debug, T11: Debug + ?Sized, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug,` [src]

`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 T10: Debug, T11: Debug + ?Sized, T6: Debug, T7: Debug, T8: Debug, T9: Debug,` [src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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,` [src]

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

`impl<T> Debug for *const T where T: ?Sized,` [src]

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

`impl<T> Debug for *mut T where T: ?Sized,` [src]

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

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

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

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

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

`impl<T> Debug for Cell<T> where T: Copy + Debug,` [src]

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

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

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

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

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

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

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

`impl<T> Debug for std::collections::binary_heap::IntoIter<T> where T: Debug,` [src]

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

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

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

`impl<T> Debug for std::collections::btree_set::IntoIter<T> where T: Debug,` [src]

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

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

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

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

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

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

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

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

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

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

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

`impl<T> Debug for std::collections::vec_deque::IntoIter<T> where T: Debug,` [src]

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

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

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

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

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

`impl<T> Debug for std::iter::Empty<T>`[src]

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

`impl<T> Debug for std::iter::Once<T> where T: Debug,` [src]

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

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

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

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

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

`impl<T> Debug for PhantomData<T> where T: ?Sized,` [src]

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

`impl<T> Debug for Discriminant<T>`[src]

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

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

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

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

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

`impl<T> Debug for NonNull<T> where T: ?Sized,` [src]

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

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

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

`impl<T> Debug for std::rc::Weak<T> where T: Debug + ?Sized,` [src]

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

`impl<T> Debug for std::result::IntoIter<T> where T: Debug,` [src]

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

`impl<T> Debug for AtomicPtr<T>`[src]

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

`impl<T> Debug for Receiver<T>`[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>`[src]

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

`impl<T> Debug for SyncSender<T>`[src]

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

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

`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,` [src]

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

`impl<T> Debug for JoinHandle<T>`[src]

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

`impl<T> Debug for std::vec::IntoIter<T> where T: Debug,` [src]

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

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

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

`impl<T> Debug for MaybeUninit<T>`[src]

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

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

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

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

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

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

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[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::Difference<'_, T, S> where T: Debug + Eq + Hash, S: BuildHasher,` [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,` [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,` [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,` [src]

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

`impl<T, const N: usize> Debug for [T; N] where T: Debug,` [src]

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

`impl<T, const N: usize> Debug for std::array::IntoIter<T, N> where T: Debug,` [src]

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

`impl<T: 'static> Debug for LocalKey<T>`[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>`[src]

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

`impl<T: Debug> Debug for std::sync::mpsc::IntoIter<T>`[src]

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

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

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

`impl<T: Debug, '_> Debug for RwLockWriteGuard<'_, T>`[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 RwLock<T>`[src]

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

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

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

`impl<W: Debug> Debug for IntoInnerError<W>`[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<Y, R> Debug for GeneratorState<Y, R> where R: Debug, Y: Debug,` [src]

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

Loading content...

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/fmt/trait.Debug.html

Trait std::fmt::Debug

Stability

Examples

Required methods

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

Examples

Implementations on Foreign Types

impl Debug for __m512[src]

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

impl Debug for __m256d[src]

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

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

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

impl Debug for __m64[src]

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

impl Debug for __m256[src]

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

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

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

impl Debug for __m512d[src]

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

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

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

impl Debug for __m128[src]

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

impl Debug for CpuidResult[src]

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

impl Debug for Utf8Lossy[src]

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

impl Debug for __m128d[src]

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

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

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

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

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

impl Debug for __m512i[src]

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

impl Debug for __m256i[src]

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

impl Debug for __m128i[src]

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]

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

impl Debug for TryReserveError[src]

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

impl Debug for Infallible[src]

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[src]

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

impl Debug for Alignment[src]

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[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]

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

impl Debug for IntErrorKind[src]

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

impl Debug for SearchStep[src]

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

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

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

impl Debug for RecvTimeoutError[src]

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

impl Debug for TryRecvError[src]

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

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

`impl Debug for __m512`[src]

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

`impl Debug for __m256d`[src]

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

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

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

`impl Debug for __m64`[src]

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

`impl Debug for __m256`[src]

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

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

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

`impl Debug for __m512d`[src]

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

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

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

`impl Debug for __m128`[src]

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

`impl Debug for CpuidResult`[src]

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

`impl Debug for Utf8Lossy`[src]

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

`impl Debug for __m128d`[src]

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

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

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

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

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

`impl Debug for __m512i`[src]

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

`impl Debug for __m256i`[src]

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

`impl Debug for __m128i`[src]

`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]

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

`impl Debug for TryReserveError`[src]

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

`impl Debug for Infallible`[src]

`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`[src]

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

`impl Debug for Alignment`[src]

`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`[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]

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

`impl Debug for IntErrorKind`[src]

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

`impl Debug for SearchStep`[src]

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

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

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

`impl Debug for RecvTimeoutError`[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 bool`[src]

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

`impl Debug for char`[src]

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

`impl Debug for f32`[src]

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

`impl Debug for f64`[src]