Trait geng_core::prelude::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<K> Debug for IntoIter<K> where
    K: Debug, 

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

impl<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

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

impl Debug for Once

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

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

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

impl Debug for BarrierWaitResult

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

impl Debug for Empty

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

impl Debug for RecvTimeoutError

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

impl<'_, T> Debug for MutexGuard<'_, T> where
    T: Debug + ?Sized, 

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

impl<'_, K, V, S> Debug for RawEntryBuilder<'_, K, V, S>

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

impl Debug for IpAddr

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

impl Debug for File

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

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Debug, 

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

impl Debug for ChildStdout

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

impl Debug for UnixDatagram

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

impl<'_> Debug for Display<'_>

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

impl Debug for Stdin

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

impl<T> Debug for Sender<T>

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

impl Debug for ChildStderr

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

impl<T> Debug for IntoIter<T> where
    T: Debug, 

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

impl<T> Debug for Key<T>

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

impl<'_, T> Debug for RwLockReadGuard<'_, T> where
    T: Debug, 

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

impl<W> Debug for IntoInnerError<W> where
    W: Debug, 

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

impl<'a> Debug for Incoming<'a>

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

impl<'_, T, S> Debug for Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>

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

impl Debug for CStr

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

impl Debug for PathBuf

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

impl<'a> Debug for PrefixComponent<'a>

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

impl Debug for AddrParseError

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

impl Debug for ExitCode

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

impl<'_, T, S> Debug for SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl Debug for SocketAddr

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

impl Debug for FromBytesWithNulError

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

impl<B> Debug for Lines<B> where
    B: Debug, 

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

impl<T> Debug for JoinHandle<T>

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

impl<'_> Debug for StderrLock<'_>

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

impl<T> Debug for SendError<T>

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

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

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

impl Debug for VarsOs

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

impl Debug for BacktraceStatus

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

impl<T> Debug for Key<T>

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

impl Debug for OpenOptions

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

impl<'a> Debug for Prefix<'a>

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

impl<'_, T, S> Debug for Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl Debug for JoinPathsError

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

impl Debug for OsString

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

impl<'_, K, V> Debug for Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<W> Debug for LineWriter<W> where
    W: Write + Debug, 

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

impl<'a> Debug for Chain<'a>

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

impl Debug for Sink

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

impl<T> Debug for Receiver<T>

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

impl Debug for UdpSocket

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

impl Debug for ArgsOs

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

impl Debug for Stdout

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

impl<T> Debug for PoisonError<T>

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

impl<'a> Debug for Ancestors<'a>

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

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

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

impl<'a, T> Debug for TryIter<'a, T> where
    T: 'a + Debug, 

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

impl<'_, K, V> Debug for OccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl Debug for TryRecvError

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

impl<'a> Debug for Incoming<'a>

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

impl Debug for NulError

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

impl<R> Debug for Bytes<R> where
    R: Debug, 

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

impl Debug for IntoStringError

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

impl Debug for Ipv6Addr

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

impl<'_, K, V, S> Debug for RawVacantEntryMut<'_, K, V, S>

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

impl Debug for Ipv6MulticastScope

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

impl<T> Debug for TrySendError<T>

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

impl<'_> Debug for Components<'_>

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

impl Debug for WaitTimeoutResult

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

impl Debug for RecvError

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

impl<'_, K> Debug for Drain<'_, K> where
    K: Debug, 

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

impl Debug for Path

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

impl<T> Debug for SyncSender<T>

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

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl Debug for UnixStream

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

impl Debug for Stdio

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

impl Debug for Instant

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

impl Debug for Command

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

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 SocketAddrV4

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

impl Debug for DirEntry

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

impl Debug for ReadDir

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

impl<T> Debug for LocalKey<T> where
    T: 'static, 

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

impl<'_> Debug for SplitPaths<'_>

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

impl Debug for Repeat

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

impl Debug for ChildStdin

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

impl Debug for Initializer

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

impl Debug for Vars

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

impl Debug for FromVecWithNulError

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

impl Debug for System

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

impl Debug for SocketAddr

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

impl<W> Debug for BufWriter<W> where
    W: Write + Debug, 

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

impl Debug for TcpStream

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

impl Debug for DirBuilder

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

impl<'_> Debug for Iter<'_>

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

impl Debug for Barrier

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

impl<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

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

impl Debug for SystemTimeError

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

impl Debug for DefaultHasher

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

impl Debug for FileType

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

impl Debug for Builder

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

impl<'a> Debug for Component<'a>

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

impl<'_> Debug for StdoutLock<'_>

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

impl Debug for VarError

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

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

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

impl<'_> Debug for StdinLock<'_>

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

impl<T> Debug for TryLockError<T>

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

impl Debug for Shutdown

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

impl Debug for SystemTime

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

impl Debug for Stderr

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

impl Debug for Ipv4Addr

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

impl Debug for SocketAddrV6

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

impl Debug for ThreadId

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

impl<T> Debug for Cursor<T> where
    T: Debug, 

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

impl Debug for TcpListener

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

impl<T> Debug for Take<T> where
    T: Debug, 

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

impl Debug for Permissions

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

impl Debug for AccessError

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

impl Debug for Condvar

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

impl Debug for StripPrefixError

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

impl<R> Debug for BufReader<R> where
    R: Debug, 

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

impl Debug for Metadata

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

impl Debug for Child

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

impl Debug for OsStr

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

impl<'_, K, V> Debug for Entry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<B> Debug for Split<B> where
    B: Debug, 

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

impl Debug for Output

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

impl Debug for OnceState

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

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl Debug for ExitStatus

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

impl<T> Debug for RwLock<T> where
    T: Debug + ?Sized, 

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

impl Debug for Backtrace

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

impl<'_, T> Debug for RwLockWriteGuard<'_, T> where
    T: Debug, 

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

impl Debug for CString

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

impl Debug for UnixListener

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

impl<'_, K, V> Debug for RawOccupiedEntryMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl Debug for RandomState

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

impl Debug for Args

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

impl<T> Debug for AssertUnwindSafe<T> where
    T: Debug, 

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

impl Debug for Thread

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

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

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

impl<T> Debug for Pending<T> where
    T: Debug, 

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

impl Debug for __m256

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

impl Debug for __m128d

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

impl<Ret> Debug for fn() -> Ret

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

impl Debug for ParseIntError

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

impl Debug for NonZeroI64

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

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

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

impl Debug for i8

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

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

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

impl Debug for EscapeDebug

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

impl Debug for NonZeroIsize

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

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

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

impl<Ret, A, B, C, D, E, F, G, H> Debug for fn(A, B, C, D, E, F, G, H) -> Ret

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

impl Debug for ToLowercase

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

impl Debug for NonZeroI16

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

impl Debug for TryFromSliceError

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

impl<T> Debug for ManuallyDrop<T> where
    T: Debug + ?Sized, 

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

impl Debug for i16

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

impl<I> Debug for Skip<I> where
    I: Debug, 

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

impl Debug for DecodeUtf16Error

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

impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E) -> Ret

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

impl<T> Debug for NonNull<T> where
    T: ?Sized, 

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

impl<'a, T> Debug for ChunksExact<'a, T> where
    T: 'a + Debug, 

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

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

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

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

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

impl<T, E> Debug for Result<T, E> where
    E: Debug,
    T: Debug, 

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

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

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

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

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

impl Debug for BorrowMutError

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

impl<I> Debug for Peekable<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

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

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

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

impl Debug for ToUppercase

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

impl Debug for Utf8Lossy

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

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, 

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

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

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

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

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

impl Debug for TypeId

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

impl Debug for PhantomPinned

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

impl Debug for RangeFull

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

impl<A> Debug for Repeat<A> where
    A: Debug, 

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

impl<Idx> Debug for RangeFrom<Idx> where
    Idx: Debug, 

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

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

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

impl Debug for __m128i

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

impl<'_> Debug for Arguments<'_>

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

impl Debug for AtomicI64

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

impl Debug for __m256i

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

impl<'a> Debug for SplitWhitespace<'a>

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

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, 

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

impl<Ret, A, B, C> Debug for unsafe fn(A, B, C) -> Ret

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

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

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

impl Debug for Utf8Error

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

impl Debug for NonZeroU128

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

impl<F> Debug for OnceWith<F> where
    F: Debug, 

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

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, 

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

impl Debug for ParseCharError

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

impl Debug for AtomicIsize

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

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

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

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

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

impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E, ...) -> Ret

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

impl Debug for FpCategory

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

impl<Ret> Debug for extern "C" fn() -> Ret

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

impl Debug for __m512

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

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

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

impl<'a> Debug for EscapeDebug<'a>

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

impl Debug for f64

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

impl Debug for ParseFloatError

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

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

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

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, 

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

impl<A, B> Debug for Zip<A, B> where
    A: Debug,
    B: Debug, 

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

impl<F> Debug for RepeatWith<F> where
    F: Debug, 

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

impl<T> Debug for Empty<T>

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

impl<'a, P> Debug for MatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl Debug for AtomicI32

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

impl<'a, T> Debug for Chunks<'a, T> where
    T: 'a + Debug, 

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

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

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

impl<T> Debug for Discriminant<T>

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

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

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

impl<Ret, A, B, C, D, E, F, G> Debug for unsafe fn(A, B, C, D, E, F, G) -> Ret

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

impl Debug for u128

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

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

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

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

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

impl<'_> Debug for Chars<'_>

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

impl Debug for u32

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

impl<'a> Debug for Bytes<'a>

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

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

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

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

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

impl<T> Debug for *mut T where
    T: ?Sized, 

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

impl<Ret, A, B, C, D, E> Debug for fn(A, B, C, D, E) -> Ret

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

impl<'a> Debug for EscapeDefault<'a>

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

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

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

impl<T10, T11> Debug for (T10, T11) where
    T10: Debug,
    T11: Debug + ?Sized, 

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

impl<T> Debug for Once<T> where
    T: Debug, 

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

impl<I, U, F> Debug for FlatMap<I, U, F> where
    I: Debug,
    U: IntoIterator,
    <U as IntoIterator>::IntoIter: Debug, 

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

impl<T> Debug for AtomicPtr<T>

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

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

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

impl Debug for NonZeroU32

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

impl<'a, T> Debug for ChunksMut<'a, T> where
    T: 'a + Debug, 

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

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

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

impl Debug for AtomicU8

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

impl<T> Debug for *const T where
    T: ?Sized, 

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

impl<'a, T> Debug for RChunks<'a, T> where
    T: 'a + Debug, 

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

impl<'a, 'f> Debug for VaList<'a, 'f> where
    'f: 'a, 

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

impl Debug for usize

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

impl Debug for NonZeroU8

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

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, 

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

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

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

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

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

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

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

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

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

impl<'f> Debug for VaListImpl<'f>

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

impl<Idx> Debug for RangeTo<Idx> where
    Idx: Debug, 

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

impl<'_, T, P> Debug for RSplitN<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: Debug, 

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

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

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

impl<I, P> Debug for TakeWhile<I, P> where
    I: Debug, 

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

impl Debug for __m512d

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

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

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

impl Debug for u8

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

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

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

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, 

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

impl<I> Debug for Enumerate<I> where
    I: Debug, 

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

impl<'a, P> Debug for SplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl<I> Debug for Take<I> where
    I: Debug, 

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

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, 

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

impl Debug for AtomicU64

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

impl Debug for NonZeroU64

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

impl Debug for AtomicBool

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

impl<'a> Debug for SplitAsciiWhitespace<'a>

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

impl<'a, T> Debug for ChunksExactMut<'a, T> where
    T: 'a + Debug, 

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

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, 

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

impl Debug for ReallocPlacement

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

impl Debug for str

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

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

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

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

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

impl Debug for __m64

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

impl<T> Debug for IntoIter<T> where
    T: Debug, 

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

impl Debug for Alignment

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

impl<T> Debug for Wrapping<T> where
    T: Debug, 

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

impl<'_, T, P> Debug for SplitN<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: Debug, 

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

impl<Ret, A, B, C, D> Debug for fn(A, B, C, D) -> Ret

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

impl Debug for i128

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

impl<Ret, A, B, C, D, E, F> Debug for fn(A, B, C, D, E, F) -> Ret

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

impl<'a, P> Debug for Split<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl<I, P> Debug for MapWhile<I, P> where
    I: Debug, 

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

impl Debug for AtomicU32

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

impl Debug for i64

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

impl Debug for Ordering

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

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

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

impl Debug for TryFromIntError

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

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

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

impl<'a, P> Debug for RSplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl Debug for __m256d

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

impl Debug for Layout

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

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

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

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

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

impl Debug for SipHasher

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

impl<I> Debug for Copied<I> where
    I: Debug, 

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

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

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

impl Debug for CharTryFromError

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

impl<Ret> Debug for unsafe extern "C" fn() -> Ret

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

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

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

impl<T11> Debug for (T11,) where
    T11: Debug + ?Sized, 

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

impl<'a, A> Debug for IterMut<'a, A> where
    A: 'a + Debug, 

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

impl<T> Debug for UnsafeCell<T> where
    T: Debug + ?Sized, 

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

impl Debug for NonZeroI128

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

impl<'a, T> Debug for RChunksExactMut<'a, T> where
    T: 'a + Debug, 

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

impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F) -> Ret

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

impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

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

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

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

impl<I> Debug for StepBy<I> where
    I: Debug, 

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

impl Debug for dyn Any + 'static + Send

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

impl Debug for EscapeDefault

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

impl<'a> Debug for CharIndices<'a>

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

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

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

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

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

impl<'a, P> Debug for Matches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl<T> Debug for Ready<T> where
    T: Debug, 

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

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

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

impl<'a> Debug for CharSearcher<'a>

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

impl<'a, T> Debug for Windows<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for RChunksExact<'a, T> where
    T: 'a + Debug, 

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

impl Debug for EscapeUnicode

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

impl<'a, A> Debug for Iter<'a, A> where
    A: 'a + Debug, 

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

impl<I, St, F> Debug for Scan<I, St, F> where
    I: Debug,
    St: Debug, 

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

impl Debug for LayoutErr

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

impl<'a, P> Debug for RMatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl<Ret, A, B, C, D, E> Debug for unsafe fn(A, B, C, D, E) -> Ret

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

impl Debug for AtomicI16

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

impl<'a, T> Debug for RChunksMut<'a, T> where
    T: 'a + Debug, 

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

impl<'a> Debug for LinesAny<'a>

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

impl<I, F> Debug for Map<I, F> where
    I: Debug, 

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

impl<T> Debug for MaybeUninit<T>

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

impl<'a, P> Debug for RSplit<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl Debug for Ordering

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

impl<A> Debug for IntoIter<A> where
    A: Debug, 

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

impl<Ret, A, B, C, D, E, F> Debug for unsafe fn(A, B, C, D, E, F) -> Ret

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

impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E) -> Ret

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

impl<'_, T, P> Debug for RSplit<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: Debug, 

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

impl<'a, P> Debug for RMatches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

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

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

impl<I, U> Debug for Flatten<I> where
    I: Debug + Iterator,
    U: Debug + Iterator,
    <I as Iterator>::Item: IntoIterator,
    <<I as Iterator>::Item as IntoIterator>::IntoIter == U,
    <<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item, 

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

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

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

impl Debug for NoneError

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

impl Debug for isize

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

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

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

impl Debug for IntErrorKind

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

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

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

impl<'a> Debug for PanicInfo<'a>

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

impl<Ret, A, B> Debug for unsafe fn(A, B) -> Ret

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

impl Debug for Duration

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

impl<'a> Debug for Location<'a>

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

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

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

impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D, ...) -> Ret

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

impl<I> Debug for Fuse<I> where
    I: Debug, 

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

impl Debug for AllocErr

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

impl Debug for Error

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

impl Debug for ()

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

impl<I, F> Debug for Inspect<I, F> where
    I: Debug, 

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

impl<Ret> Debug for unsafe fn() -> Ret

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

impl<Ret, A> Debug for unsafe fn(A) -> Ret

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

impl Debug for Infallible

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

impl<T> Debug for Reverse<T> where
    T: Debug, 

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

impl<Ret, A, B> Debug for fn(A, B) -> Ret

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

impl<A, B> Debug for Chain<A, B> where
    A: Debug,
    B: Debug, 

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

impl<I, F> Debug for FilterMap<I, F> where
    I: Debug, 

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

impl<'a, P> Debug for RSplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl<H> Debug for BuildHasherDefault<H>

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

impl<'a> Debug for Utf8LossyChunk<'a>

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

impl Debug for NonZeroI32

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

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

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

impl<T> Debug for Option<T> where
    T: Debug, 

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

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

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

impl<I, P> Debug for Filter<I, P> where
    I: Debug, 

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

impl<Ret, A> Debug for extern "C" fn(A) -> Ret

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

impl<const N: usize, T> Debug for IntoIter<T, N> where
    T: Debug,
    [T; N]: LengthAtMost32, 

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

impl Debug for u16

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

impl<I> Debug for DecodeUtf16<I> where
    I: Debug + Iterator<Item = u16>, 

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

impl Debug for BorrowError

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

impl<'_> Debug for EncodeUtf16<'_>

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

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

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

impl<I> Debug for Cycle<I> where
    I: Debug, 

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

impl Debug for dyn Any + 'static

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

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

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

impl Debug for SearchStep

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

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

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

impl<'a, P> Debug for SplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl<'_, T> Debug for &'_ T where
    T: Debug + ?Sized, 

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

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

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

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

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

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

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

impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D) -> Ret

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

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

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

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

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

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

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

impl<Idx> Debug for RangeToInclusive<Idx> where
    Idx: Debug, 

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

impl<I, P> Debug for SkipWhile<I, P> where
    I: Debug, 

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

impl<Ret, A, B, C, D> Debug for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

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

impl Debug for dyn Any + 'static + Sync + Send

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

impl<Ret, A, B, C, D> Debug for unsafe extern "C" fn(A, B, C, D) -> Ret

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

impl Debug for ParseBoolError

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

impl Debug for f32

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

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

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

impl<'_, T, P> Debug for Split<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: Debug, 

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

impl Debug for CpuidResult

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

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

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

impl<T> Debug for Rev<T> where
    T: Debug, 

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

impl Debug for AllocInit

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

impl Debug for char

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

impl Debug for __m512i

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

impl Debug for u64

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

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

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

impl<Ret, A, B, C> Debug for fn(A, B, C) -> Ret

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

impl Debug for NonZeroUsize

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

impl<'a, 'b> Debug for StrSearcher<'a, 'b>

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

impl<Ret, A, B, C, D, E, F, G> Debug for fn(A, B, C, D, E, F, G) -> Ret

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

impl Debug for bool

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

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

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

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

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

impl Debug for AtomicUsize

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

impl<Y, R> Debug for GeneratorState<Y, R> where
    R: Debug,
    Y: Debug, 

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

impl Debug for EscapeDefault

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

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

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

impl<F> Debug for FromFn<F>

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

impl<'a> Debug for Lines<'a>

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

impl Debug for MemoryBlock

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

impl Debug for AtomicU16

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

impl<Ret, A> Debug for fn(A) -> Ret

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

impl Debug for NonZeroI8

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

impl Debug for AtomicI8

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

impl Debug for __m128

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

impl<'a> Debug for EscapeUnicode<'a>

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

impl Debug for i32

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

impl<I> Debug for Cloned<I> where
    I: Debug, 

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

impl Debug for NonZeroU16

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

impl<T, F> Debug for Successors<T, F> where
    T: Debug, 

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

impl Debug for !

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

impl<T> Debug for Vec<T> where
    T: Debug, 

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

impl<T> Debug for LinkedList<T> where
    T: Debug, 

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

impl<'_, T> Debug for Cursor<'_, T> where
    T: Debug, 

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

impl<K, V> Debug for BTreeMap<K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, T> Debug for Drain<'_, T> where
    T: Debug, 

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

impl<T> Debug for IntoIter<T> where
    T: Debug, 

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

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug, 

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

impl<'_, T> Debug for Drain<'_, T> where
    T: Debug, 

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

impl Debug for FromUtf16Error

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

impl<'_, K, V> Debug for RangeMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized, 

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

impl<'_, T> Debug for PeekMut<'_, T> where
    T: Ord + Debug, 

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

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

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

impl<T> Debug for IntoIterSorted<T> where
    T: Debug, 

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

impl<T> Debug for BTreeSet<T> where
    T: Debug, 

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

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

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

impl<'_, B> Debug for Cow<'_, B> where
    B: Debug + ToOwned + ?Sized,
    <B as ToOwned>::Owned: Debug, 

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

impl<'_> Debug for Drain<'_>

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

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized, 

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

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

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

impl<'_, T> Debug for Intersection<'_, T> where
    T: Debug, 

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

impl<T> Debug for IntoIter<T> where
    T: Debug, 

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

impl<'a, K, V> Debug for ValuesMut<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

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

impl<'a, T> Debug for DrainSorted<'a, T> where
    T: Ord + Debug, 

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

impl<'_, K, V, F> Debug for DrainFilter<'_, K, V, F> where
    F: FnMut(&K, &mut V) -> bool,
    K: Debug,
    V: Debug, 

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

impl<'_, T> Debug for Difference<'_, T> where
    T: Debug, 

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

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for OccupiedEntry<'_, K, V> where
    K: Ord + Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for Range<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, T, F> Debug for DrainFilter<'_, T, F> where
    F: FnMut(&mut T) -> bool,
    T: Debug, 

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

impl Debug for Global

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

impl Debug for String

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

impl<'a, T, F> Debug for DrainFilter<'a, T, F> where
    F: Debug + FnMut(&mut T) -> bool,
    T: Debug, 

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

impl<T> Debug for IntoIter<T> where
    T: Debug, 

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

impl<'_, T> Debug for Union<'_, T> where
    T: Debug, 

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

impl<T> Debug for IntoIter<T> where
    T: Debug, 

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

impl<T> Debug for Box<T> where
    T: Debug + ?Sized, 

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

impl<T> Debug for BinaryHeap<T> where
    T: Debug, 

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

impl Debug for TryReserveError

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

impl<T> Debug for VecDeque<T> where
    T: Debug, 

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

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

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

impl<'a, K, V> Debug for IterMut<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

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

impl<'_, T> Debug for SymmetricDifference<'_, T> where
    T: Debug, 

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

impl<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Ord + Debug, 

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

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

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

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

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

impl<'_, T> Debug for CursorMut<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

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

impl<'_, T, F> Debug for DrainFilter<'_, T, F> where
    F: FnMut(&T) -> bool,
    T: Debug, 

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

impl<'_, K, V> Debug for Entry<'_, K, V> where
    K: Ord + Debug,
    V: Debug, 

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

impl<T> Debug for IntoIter<T> where
    T: Debug, 

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

impl Debug for FromUtf8Error

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

impl<'a, I> Debug for Splice<'a, I> where
    I: 'a + Iterator + Debug,
    <I as Iterator>::Item: Debug, 

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

impl<'a, T> Debug for Range<'a, T> where
    T: 'a + Debug, 

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

impl Debug for _Unwind_Reason_Code

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

impl Debug for Frame

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

impl<'a> Debug for SymbolName<'a>

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

impl Debug for Symbol

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

impl<'a> Debug for BytesOrWideString<'a>

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

impl Debug for TryDemangleError

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

impl<'a> Debug for Demangle<'a>

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

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, T, S> Debug for SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, K, V, S> Debug for OccupiedEntry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

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

impl<K> Debug for IntoIter<K> where
    K: Debug, 

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

impl<'_, K, V, S> Debug for RawEntryBuilder<'_, K, V, S>

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

impl<'_, K, V, S> Debug for RawVacantEntryMut<'_, K, V, S>

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

impl<T, S> Debug for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash + Debug, 

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

impl<'_, K, V, S> Debug for VacantEntry<'_, K, V, S> where
    K: Debug, 

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

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, T, S> Debug for Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, K, V> Debug for RustcOccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K> Debug for Drain<'_, K> where
    K: Debug, 

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

impl<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

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

impl<'_, K, V> Debug for Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for RustcEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>

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

impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Debug,
    S: BuildHasher,
    V: Debug, 

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

impl Debug for CollectionAllocErr

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

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

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

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for RustcVacantEntry<'_, K, V> where
    K: Debug, 

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

impl<'_, K, V, S> Debug for Entry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

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

impl<'_, T, S> Debug for Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for RawOccupiedEntryMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<E> Debug for Compat<E> where
    E: Debug, 

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

impl Debug for Backtrace

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

impl<D> Debug for Context<D> where
    D: 'static + Send + Sync + Display, 

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

impl<T> Debug for SyncFailure<T> where
    T: Debug, 

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

impl Debug for Symbol

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

impl Debug for Backtrace

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

impl<'a> Debug for BytesOrWideString<'a>

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

impl Debug for BacktraceSymbol

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

impl Debug for Frame

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

impl<'a> Debug for SymbolName<'a>

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

impl Debug for BacktraceFrame

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

impl<'a> Debug for Demangle<'a>

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

impl Debug for TryDemangleError

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

impl<T> Debug for ArangeEntry<T> where
    T: Copy + Debug, 

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

impl<R> Debug for DebugRanges<R> where
    R: Debug, 

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

impl<R> Debug for LineInstructions<R> where
    R: Reader + Debug, 

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

impl<T> Debug for DebugInfoOffset<T> where
    T: Debug, 

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

impl<R> Debug for DebugLineStr<R> where
    R: Debug, 

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

impl<T> Debug for DebugLocListsIndex<T> where
    T: Debug, 

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

impl<R, Offset> Debug for Piece<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<T> Debug for DebugLocListsBase<T> where
    T: Debug, 

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

impl Debug for DwUt

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

impl<R> Debug for EhFrameHdr<R> where
    R: Reader + Debug, 

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

impl<R> Debug for DebugLocLists<R> where
    R: Debug, 

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

impl Debug for Augmentation

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

impl Debug for DwAccess

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

impl<R> Debug for DebugFrame<R> where
    R: Reader + Debug, 

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

impl<R> Debug for CfaRule<R> where
    R: Reader + Debug, 

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

impl<R> Debug for PubTypesEntryIter<R> where
    R: Reader + Debug, 

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

impl<R, Offset> Debug for CompilationUnitHeader<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for DwRle

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

impl<R> Debug for RawLocListEntry<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl Debug for DwAte

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

impl<'abbrev, 'unit, R> Debug for EntriesTree<'abbrev, 'unit, R> where
    R: Debug + Reader, 

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

impl<'input, Endian> Debug for EndianSlice<'input, Endian> where
    Endian: Debug + Endianity, 

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

impl<R> Debug for UnwindTableRow<R> where
    R: Reader + Debug, 

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

impl<R> Debug for DebugAranges<R> where
    R: Reader + Debug, 

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

impl<T> Debug for RangeListsOffset<T> where
    T: Debug, 

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

impl Debug for SectionId

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

impl<R, Offset> Debug for TypeUnitHeader<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<T> Debug for EhFrameOffset<T> where
    T: Debug, 

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

impl<R> Debug for RawLocListIter<R> where
    R: Reader + Debug, 

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

impl Debug for X86

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

impl Debug for DwEhPe

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

impl<R> Debug for CompilationUnitHeadersIter<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl Debug for X86_64

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

impl<'a, R> Debug for EhHdrTable<'a, R> where
    R: Reader + Debug, 

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

impl<R, Offset> Debug for CompleteLineProgram<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R, Offset> Debug for LineProgramHeader<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for Abbreviations

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

impl<R> Debug for LineSequence<R> where
    R: Reader + Debug, 

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

impl<'abbrev, 'unit, 'tree, R> Debug for EntriesTreeNode<'abbrev, 'unit, 'tree, R> where
    R: Reader + Debug, 

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

impl<'a, R> Debug for CallFrameInstructionIter<'a, R> where
    R: Reader + Debug, 

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

impl Debug for DwOp

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

impl Debug for DwAt

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

impl<'abbrev, 'unit, 'tree, R> Debug for EntriesTreeIter<'abbrev, 'unit, 'tree, R> where
    R: Reader + Debug, 

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

impl<R> Debug for Dwarf<R> where
    R: Debug, 

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

impl Debug for BigEndian

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

impl<R> Debug for RangeIter<R> where
    R: Reader + Debug, 

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

impl<R> Debug for DebugAbbrev<R> where
    R: Debug, 

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

impl Debug for ReaderOffsetId

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

impl<R, Offset> Debug for Unit<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for DwDefaulted

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

impl<T> Debug for DebugMacroOffset<T> where
    T: Debug, 

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

impl Debug for DebugTypeSignature

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

impl<R> Debug for UninitializedUnwindContext<R> where
    R: Reader + Debug, 

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

impl<R> Debug for CallFrameInstruction<R> where
    R: Reader + Debug, 

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

impl Debug for DwLns

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

impl<R> Debug for ParsedEhFrameHdr<R> where
    R: Reader + Debug, 

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

impl<T> Debug for DebugStrOffsetsBase<T> where
    T: Debug, 

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

impl<R> Debug for DebugTypes<R> where
    R: Debug, 

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

impl Debug for LittleEndian

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

impl<R> Debug for DebugLine<R> where
    R: Debug, 

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

impl<R> Debug for DebugLoc<R> where
    R: Debug, 

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

impl Debug for DwVis

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

impl<R> Debug for DebugInfo<R> where
    R: Debug, 

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

impl<T> Debug for UnitOffset<T> where
    T: Debug, 

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

impl<T> Debug for LocationListsOffset<T> where
    T: Debug, 

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

impl<R> Debug for LocationLists<R> where
    R: Debug, 

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

impl<T> Debug for DebugStrOffsetsIndex<T> where
    T: Debug, 

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

impl Debug for Register

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

impl Debug for DwLang

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

impl Debug for DwDs

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

impl<T> Debug for DebugRngListsIndex<T> where
    T: Debug, 

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

impl<R> Debug for LocationListEntry<R> where
    R: Reader + Debug, 

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

impl<T> Debug for DebugStrOffset<T> where
    T: Debug, 

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

impl<R> Debug for RawRngListIter<R> where
    R: Reader + Debug, 

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

impl<R> Debug for DebugStrOffsets<R> where
    R: Debug, 

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

impl<R, Offset> Debug for IncompleteLineProgram<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R> Debug for TypeUnitHeadersIter<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl<R, Offset> Debug for Location<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for Value

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

impl Debug for DwLne

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

impl<T> Debug for DebugLineStrOffset<T> where
    T: Debug, 

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

impl Debug for DwLnct

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

impl<T> Debug for DebugAddrBase<T> where
    T: Debug, 

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

impl Debug for ValueType

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

impl<R, Offset> Debug for FrameDescriptionEntry<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for DwForm

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

impl<R> Debug for RngListIter<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl Debug for Error

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

impl<R> Debug for DebugPubTypes<R> where
    R: Reader + Debug, 

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

impl Debug for Arm

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

impl<R, Offset> Debug for FileEntry<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<T> Debug for DebugMacinfoOffset<T> where
    T: Debug, 

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

impl<R> Debug for DebugRngLists<R> where
    R: Debug, 

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

impl<R> Debug for DebugAddr<R> where
    R: Debug, 

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

impl<R> Debug for Expression<R> where
    R: Reader + Debug, 

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

impl Debug for LineRow

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

impl Debug for DwOrd

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

impl Debug for DwInl

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

impl<'abbrev, 'unit, R, Offset> Debug for DebuggingInformationEntry<'abbrev, 'unit, R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for Range

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

impl Debug for Abbreviation

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

impl Debug for DwCc

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

impl<R, Offset> Debug for CommonInformationEntry<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for DwMacro

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

impl<'abbrev, 'entry, 'unit, R> Debug for AttrsIter<'abbrev, 'entry, 'unit, R> where
    R: Reader + Debug, 

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

impl<'abbrev, 'unit, R> Debug for EntriesCursor<'abbrev, 'unit, R> where
    R: Debug + Reader, 

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

impl<R> Debug for EhFrame<R> where
    R: Reader + Debug, 

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

impl<R> Debug for ArangeEntryIter<R> where
    R: Reader + Debug, 

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

impl<'a, R> Debug for UnwindTable<'a, R> where
    R: Reader + Debug, 

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

impl<R, Offset> Debug for AttributeValue<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R> Debug for RangeLists<R> where
    R: Debug, 

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

impl Debug for DwVirtuality

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

impl Debug for Format

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

impl Debug for Encoding

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

impl<R> Debug for DebugStr<R> where
    R: Debug, 

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

impl<R, Offset> Debug for LineInstruction<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for LineEncoding

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

impl<T> Debug for DieReference<T> where
    T: Debug, 

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

impl<'bases, Section, R> Debug for PartialFrameDescriptionEntry<'bases, Section, R> where
    R: Debug + Reader,
    Section: Debug + UnwindSection<R>,
    <R as Reader>::Offset: Debug,
    <Section as UnwindSection<R>>::Offset: Debug, 

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

impl Debug for DwIdx

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

impl<R, Offset> Debug for UnitHeader<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R> Debug for PubNamesEntryIter<R> where
    R: Reader + Debug, 

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

impl Debug for ColumnType

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

impl<'bases, Section, R> Debug for CfiEntriesIter<'bases, Section, R> where
    R: Debug + Reader,
    Section: Debug + UnwindSection<R>, 

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

impl<R> Debug for Attribute<R> where
    R: Reader + Debug, 

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

impl<R> Debug for PubTypesEntry<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl<T> Debug for RawRngListEntry<T> where
    T: Debug, 

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

impl Debug for DwDsc

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

impl<R> Debug for DebugPubNames<R> where
    R: Reader + Debug, 

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

impl<T> Debug for DebugRngListsBase<T> where
    T: Debug, 

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

impl<'abbrev, 'unit, R> Debug for EntriesRaw<'abbrev, 'unit, R> where
    R: Debug + Reader, 

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

impl Debug for FileEntryFormat

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

impl Debug for DwCfa

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

impl<T> Debug for DebugAddrIndex<T> where
    T: Debug, 

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

impl Debug for DwChildren

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

impl Debug for BaseAddresses

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

impl<R> Debug for PubNamesEntry<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl<'iter, R> Debug for RegisterRuleIter<'iter, R> where
    R: Debug + Reader, 

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

impl<T> Debug for UnitSectionOffset<T> where
    T: Debug, 

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

impl Debug for RunTimeEndian

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

impl Debug for SectionBaseAddresses

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

impl<R> Debug for RegisterRule<R> where
    R: Reader + Debug, 

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

impl<R> Debug for EvaluationResult<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl<'bases, Section, R> Debug for CieOrFde<'bases, Section, R> where
    R: Debug + Reader,
    Section: Debug + UnwindSection<R>, 

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

impl<R> Debug for OperationIter<R> where
    R: Reader + Debug, 

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

impl<T> Debug for DebugTypesOffset<T> where
    T: Debug, 

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

impl<R> Debug for Evaluation<R> where
    R: Reader + Debug, 

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

impl<T> Debug for DebugAbbrevOffset<T> where
    T: Debug, 

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

impl<T> Debug for DebugFrameOffset<T> where
    T: Debug, 

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

impl Debug for DwLle

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

impl Debug for AttributeSpecification

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

impl Debug for DwEnd

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

impl Debug for DwTag

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

impl<R, Program, Offset> Debug for LineRows<R, Program, Offset> where
    Offset: Debug + ReaderOffset,
    Program: Debug + LineProgram<R, Offset>,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R, Offset> Debug for Operation<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R> Debug for UnwindContext<R> where
    R: Reader + Debug, 

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

impl Debug for DwAddr

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

impl Debug for Pointer

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

impl<T> Debug for DebugLineOffset<T> where
    T: Debug, 

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

impl<R> Debug for LocListIter<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl Debug for DwId

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

impl Debug for ImageDynamicRelocation64V2

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

impl Debug for ImagePrologueDynamicRelocationHeader

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

impl Debug for FatArch32

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

impl<E> Debug for DylibTableOfContents<E> where
    E: Endian + Debug, 

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

impl<'data, 'file> Debug for SectionIterator<'data, 'file> where
    'data: 'file, 

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

impl Debug for ImageDebugDirectory

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

impl<Section> Debug for SymbolFlags<Section> where
    Section: Debug, 

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

impl<E> Debug for DyldInfoCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageLoadConfigCodeIntegrity

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

impl<E> Debug for IdentCommand<E> where
    E: Endian + Debug, 

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

impl<'data, 'file, Pe> Debug for PeSegmentIterator<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

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

impl<E> Debug for SubClientCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageBoundImportDescriptor

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

impl<'data> Debug for SymbolMap<'data>

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

impl Debug for SectionKind

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

impl Debug for RelocationSections

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

impl<E> Debug for FileHeader32<E> where
    E: Endian + Debug, 

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

impl Debug for ImageHotPatchBase

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

impl<'data, 'file> Debug for SymbolIterator<'data, 'file> where
    'data: 'file, 

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

impl Debug for ImageAlpha64RuntimeFunctionEntry

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

impl Debug for ImageArchitectureEntry

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

impl Debug for ImportObjectHeader

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

impl<'data, Elf> Debug for ElfFile<'data, Elf> where
    Elf: FileHeader + Debug,
    <Elf as FileHeader>::Endian: Debug,
    <Elf as FileHeader>::ProgramHeader: Debug, 

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

impl<E> Debug for LcStr<E> where
    E: Endian + Debug, 

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

impl<E> Debug for FvmlibCommand<E> where
    E: Endian + Debug, 

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

impl<'data> Debug for CoffFile<'data>

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

impl Debug for Relocation

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

impl<'data> Debug for CompressedData<'data>

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

impl<E> Debug for SymtabCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageDosHeader

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

impl Debug for ImageEnclaveConfig64

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

impl<E> Debug for CompressionHeader32<E> where
    E: Endian + Debug, 

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

impl<E> Debug for SubUmbrellaCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for LinkerOptionCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageHotPatchInfo

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

impl<E> Debug for CompressionHeader64<E> where
    E: Endian + Debug, 

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

impl<E> Debug for DylinkerCommand<E> where
    E: Endian + Debug, 

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

impl Debug for AddressSize

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

impl<'data, Elf> Debug for SectionTable<'data, Elf> where
    Elf: FileHeader + Debug,
    <Elf as FileHeader>::SectionHeader: Debug, 

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

impl<E> Debug for ProgramHeader64<E> where
    E: Endian + Debug, 

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

impl<E> Debug for MachHeader32<E> where
    E: Endian + Debug, 

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

impl Debug for ImageBaseRelocation

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

impl Debug for ScatteredRelocationInfo

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

impl<E> Debug for EncryptionInfoCommand<E> where
    E: Endian + Debug, 

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

impl<'data, 'file, Elf> Debug for ElfSymbolIterator<'data, 'file, Elf> where
    Elf: FileHeader, 

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

impl<E> Debug for Rel64<E> where
    E: Endian + Debug, 

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

impl Debug for ImageOptionalHeader32

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

impl<E> Debug for RoutinesCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for NoteCommand<E> where
    E: Endian + Debug, 

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

impl Debug for BinaryFormat

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

impl<E> Debug for BuildToolVersion<E> where
    E: Endian + Debug, 

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

impl<E> Debug for Dyn64<E> where
    E: Endian + Debug, 

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

impl Debug for Error

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

impl<'data, 'file> Debug for CoffRelocationIterator<'data, 'file>

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

impl<'data> Debug for SymbolTable<'data>

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

impl<'data, 'file, Elf> Debug for ElfSegment<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::ProgramHeader: Debug, 

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

impl<E> Debug for SectionHeader64<E> where
    E: Endian + Debug, 

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

impl<E> Debug for Dylib<E> where
    E: Endian + Debug, 

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

impl Debug for ImageBoundForwarderRef

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

impl Debug for ImageDynamicRelocation32

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

impl<E> Debug for MachHeader64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data> Debug for File<'data>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for Section<'data, 'file>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSymbolIterator<'data, 'file>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageFunctionEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FatHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageFileHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeSegment<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SegmentCommand64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageImportByName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageDebugMisc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ident

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageAlphaRuntimeFunctionEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageDynamicRelocation64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I32Bytes<E> where
    E: Endian, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageAuxSymbolWeak

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSection<'data, 'file, Mach> where
    'data: 'file,
    Mach: Debug + MachHeader, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Nlist64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U16Bytes<E> where
    E: Endian, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSymbolIterator<'data, 'file, Mach> where
    Mach: MachHeader, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageSymbolEx

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for PrebindCksumCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for BuildVersionCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SubLibraryCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for NoteHeader32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageResourceDataEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSegmentIterator<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::ProgramHeader: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for LoadCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for TwolevelHintsCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfRelocationIterator<'data, 'file, Elf> where
    Elf: FileHeader, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageRomOptionalHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnonObjectHeaderBigobj

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageRomHeaders

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for SegmentIterator<'data, 'file> where
    'data: 'file, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data> Debug for SectionTable<'data>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SymbolScope

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageAuxSymbolTokenDef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Architecture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSegment<'data, 'file> where
    'data: 'file, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageCoffSymbolsHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageSymbolExBytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSection<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for DylibModule64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for TwolevelHint<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SymbolSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSection<'data, 'file> where
    'data: 'file, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SymbolIndex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnonObjectHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, Mach> Debug for SymbolTable<'data, Mach> where
    Mach: MachHeader + Debug,
    <Mach as MachHeader>::Nlist: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Syminfo32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FatArch64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for DylibCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSegmentIterator<'data, 'file, Mach> where
    'data: 'file,
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Endian: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Rela32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, Mach> Debug for MachOFile<'data, Mach> where
    Mach: MachHeader + Debug,
    <Mach as MachHeader>::Endian: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageRelocation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageTlsDirectory32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageResourceDirStringU

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSectionIterator<'data, 'file, Mach> where
    Mach: MachHeader, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, Elf> Debug for ElfNoteIterator<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for DylibReference<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Dyn32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeSection<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for RpathCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Sym64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I64Bytes<E> where
    E: Endian, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Rel32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageSectionHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageExportDirectory

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageArmRuntimeFunctionEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Rela64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for RelocationIterator<'data, 'file> where
    'data: 'file, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for EntryPointCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, Elf> Debug for SymbolTable<'data, Elf> where
    Elf: FileHeader + Debug,
    <Elf as FileHeader>::Sym: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Fvmlib<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageNtHeaders32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for FileHeader64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSectionIterator<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Sym32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageTlsDirectory64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageVxdHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, Elf> Debug for ElfNote<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::NoteHeader: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageCor20Header

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for VersionMinCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageImportDescriptor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I16Bytes<E> where
    E: Endian, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for ProgramHeader32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RelocationKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RelocationInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageSymbol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageSeparateDebugHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U64Bytes<E> where
    E: Endian, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageFunctionEntry64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LittleEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for PreboundDylibCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SubFrameworkCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, Pe> Debug for PeFile<'data, Pe> where
    Pe: ImageNtHeaders + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UuidCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageArm64RuntimeFunctionEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageEpilogueDynamicRelocationHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Section64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for LinkeditDataCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for NoteHeader64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SymbolKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSegment<'data, 'file, Mach> where
    'data: 'file,
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Segment: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSegmentIterator<'data, 'file> where
    'data: 'file, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageLoadConfigDirectory64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageOptionalHeader64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SegmentCommand32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Endianness

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageDelayloadDescriptor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for PeRelocationIterator<'data, 'file>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageResourceDirectoryEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageResourceDirectoryString

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for DataInCodeEntry<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Section32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageRuntimeFunctionEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for Segment<'data, 'file>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for EncryptionInfoCommand64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageEnclaveConfig32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for RoutinesCommand_64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageHotPatchHashes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for DysymtabCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for FvmfileCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SourceVersionCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageArchiveMemberHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Nlist32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSectionIterator<'data, 'file> where
    'data: 'file, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageAuxSymbolCrc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FileFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageAuxSymbolFunctionBeginEnd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageLoadConfigDirectory32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachORelocationIterator<'data, 'file, Mach> where
    Mach: MachHeader, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for ThreadCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageResourceDirectory

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data> Debug for Symbol<'data>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SectionIndex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageOs2Header

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageLinenumber

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RelocationTarget

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NonPagedDebugInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SectionFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageAuxSymbolSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageDynamicRelocationTable

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageNtHeaders64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U32Bytes<E> where
    E: Endian, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RelocationEncoding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageDynamicRelocation32V2

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data> Debug for Bytes<'data>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Syminfo64<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageEnclaveImport

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageDataDirectory

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for DylibModule32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data> Debug for StringTable<'data>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Relocation<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeSectionIterator<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnonObjectHeaderV2

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageSymbolBytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageAuxSymbolFunction

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Guid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SymSegCommand<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SectionHeader32<E> where
    E: Endian + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TDEFLFlush

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TINFLStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MZError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DataFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MZStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MZFlush

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TDEFLStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionStrategy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Adler32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LittleEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Style

Styles have a special Debug implementation that only shows the fields that are set. Fields that haven’t been touched aren’t included in the output.

This behaviour gets bypassed when using the alternate formatting mode format!("{:#?}").

use ansi_term::Colour::{Red, Blue};
assert_eq!("Style { fg(Red), on(Blue), bold, italic }",
           format!("{:?}", Red.on(Blue).bold().italic()));

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Infix

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Colour

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Prefix

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Suffix

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for ANSIGenericString<'a, S> where
    S: 'a + Debug + ToOwned + ?Sized,
    <S as ToOwned>::Owned: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Stream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StrSimError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'w, 'a, S> Debug for WrapIter<'w, 'a, S> where
    'a: 'w,
    S: 'w + WordSplitter + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for Wrapper<'a, S> where
    S: WordSplitter + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NoHyphenation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HyphenSplitter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for IntoWrapIter<'a, S> where
    S: WordSplitter + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<V> Debug for VecMap<V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GraphemeIncomplete

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BlockRng<R> where
    R: BlockRngCore + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BlockRng64<R> where
    R: BlockRngCore + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha20Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha20Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha12Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha8Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha12Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha8Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Number

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PrettyConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CharacterSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodeError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for EncoderWriter<'a, W> where
    W: Write, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StdErrLog

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Fixed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parsed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pad

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InternalFixed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LocalResult<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Tz> Debug for Date<Tz> where
    Tz: TimeZone, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for StrftimeItems<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Numeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveDateTime

The Debug output of the naive date and time dt is the same as dt.format("%Y-%m-%dT%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn't matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveDate;

let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");

Leap seconds may also be used.

let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RoundingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for DelayedFormat<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveDate

The Debug output of the naive date d is the same as d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

Example

use chrono::NaiveDate;

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Local

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Tz> Debug for DateTime<Tz> where
    Tz: TimeZone, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Utc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Item<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FixedOffset

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveTime

The Debug output of the naive time t is the same as t.format("%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn't matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveTime;

assert_eq!(format!("{:?}", NaiveTime::from_hms(23, 56, 4)),              "23:56:04");
assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(23, 56, 4, 12)),    "23:56:04.012");
assert_eq!(format!("{:?}", NaiveTime::from_hms_micro(23, 56, 4, 1234)),  "23:56:04.001234");
assert_eq!(format!("{:?}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");

Leap seconds may also be used.

assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SecondsFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InternalNumeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsoWeek

The Debug output of the ISO week w is the same as d.format("%G-W%V") where d is any NaiveDate value in that week.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5).iso_week()), "2015-W36");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  3).iso_week()), "0000-W01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31).iso_week()), "9999-W52");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(    0,  1,  2).iso_week()),  "-0001-W52");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31).iso_week()), "+10000-W52");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseWeekdayError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Weekday

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutOfRangeError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for TmFmt<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SteadyTime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timespec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Duration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ExtendedGcd<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FloatErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseFloatError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Color

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseColorError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorChoice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ThreadLocal<T> where
    T: Send + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CachedThreadLocal<T> where
    T: Send + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Void

fn fmt(&self, &mut Formatter) -> Result<(), Error>

impl Debug for OkCancel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for YesNo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AttributeType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProgramLinkError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WrapMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DepthComponent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ShaderCompilationError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CullFace

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BlendMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UniformInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DrawParameters

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DepthFunc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Filter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ShaderType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AttributeInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Enum> Debug for TryFromPrimitiveError<Enum> where
    Enum: TryFromPrimitive, 

fn fmt(&self, __f: &mut Formatter) -> Result<(), Error>

impl Debug for ActiveInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Rect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CreationError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContextError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixelFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PossiblyCurrent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Api

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, W> Debug for ContextWrapper<T, W> where
    T: ContextCurrentState + Debug,
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlProfile

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixelFormatRequirements

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Robustness

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReleaseBehavior

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RawHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Context<T> where
    T: ContextCurrentState + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NotCurrent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for GlAttributes<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ContextBuilder<'a, T> where
    T: ContextCurrentState + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRecordClientInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XftCharSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XPixmapFormatValues

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIHierarchyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIAnyClassInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIPropertyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XHostAddress

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRecordExtRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XKeymapEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIMPreeditCaretCallbackStruct

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XAnyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorCursors

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XftColor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XDestroyWindowEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XrmValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbStateNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XRadialGradient

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ScreenFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XftGlyphFontSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbControlsNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XFocusChangeEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XKeyboardControl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XScreenSaverNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XSpanFix

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIDeviceInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRROutputInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XWMHints

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRCrtcChangeNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIDeviceEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Depth

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRProviderResources

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XInputClassInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbCompatMapNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIValuatorClassInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XComposeStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XPointDouble

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XPropertyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRScreenSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbAnyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XClassHint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorImages

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XNoExposeEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AspectRatio

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRCrtcTransformAttributes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XPointFixed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIDetachSlaveInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XButtonEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorFile

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorFileToc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XKeyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIAnyHierarchyChangeInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbExtensionDeviceNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIGrabModifiers

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XITouchClassInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XF86VidModeMonitor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIBarrierEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XF86VidModeModeInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRecordState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XResizeRequestEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XCrossingEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRPropertyInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XF86VidModeGamma

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIDeviceChangedEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XSelectionRequestEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XMappingEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XConfigureEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageFns

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XDeviceTimeCoord

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XSelectionClearEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbNamesRec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XFontSetExtents

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XTextItem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XTimeCoord

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XFontStruct

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XftCharFontSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XSizeHints

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbBellNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRScreenChangeNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorChunkHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XExposeEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XColor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XCreateWindowEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XCharStruct

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIHierarchyInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XMapRequestEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIAddMasterInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XClientMessageEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XTrap

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbKeyNameRec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XCirculateEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XVisibilityEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XDeviceControl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XScreenSaverInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIEventMask

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIBarrierReleasePointerInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XOMCharSetList

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIMCaretDirection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorComment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbNewKeyboardNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRCrtcInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XGlyphElt16

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XReparentEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XTextItem16

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIModifierState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Visual

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XFeedbackControl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XmbTextItem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XChar2b

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XSelectionEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIRemoveMasterInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRenderPictFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRMonitorInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XAnimCursor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XrmOptionDescRec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Screen

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XVisualInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIValuatorState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRResourceChangeNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRecordRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XPanoramiXInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XftFontSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XGenericEventCookie

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XCirculateRequestEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XTrapezoid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XF86VidModeModeLine

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRROutputPropertyNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRecordInterceptData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIButtonState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbNamesNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRecordRange16

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XGraphicsExposeEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XFilters

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRProviderPropertyNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XGlyphElt32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRProviderInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIconSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIKeyClassInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XTransform

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XGCValues

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIEnterEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XColormapEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XUnmapEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XExtCodes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XSegment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbKeyAliasRec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XConicalGradient

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRScreenResources

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientMessageData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIMPreeditDrawCallbackStruct

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorComments

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XITouchOwnershipEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XStandardColormap

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRProviderChangeNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XGlyphElt8

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XRenderPictureAttributes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XDeviceState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XF86VidModeSyncRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XineramaScreenInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIScrollClassInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRPanning

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorImage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XCircle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XDeviceInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XModifierKeymap

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbActionMessageEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XPoint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XTextProperty

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XftGlyphSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XKeyboardState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XInputClass

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRModeInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRRCrtcGamma

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbAccessXNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XErrorEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRenderColor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XFeedbackState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XWindowAttributes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XMapEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XftFont

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XkbIndicatorNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XLineFixed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XDevice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XImage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRecordRange8

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XTriangle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XExtensionVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorFileHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XLinearGradient

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRenderDirectFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XGravityEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbStateRec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XSetWindowAttributes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XGlyphInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIAttachSlaveInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XF86VidModeNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XIndexValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XFontProp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XMotionEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRROutputChangeNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XRectangle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XcursorAnimate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XArc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XWindowChanges

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIMCaretStyle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XwcTextItem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbDesc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XConfigureRequestEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIButtonClassInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _XkbMapNotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XIRawEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WindowId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DeviceId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WindowId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Modifier

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Icon

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Size

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MouseButton

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NotSupportedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WindowBuilder

fn fmt(&self, fmtr: &mut Formatter) -> Result<(), Error>

impl Debug for ExternalError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XNotSupported

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VideoMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DeviceEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Format

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Window

fn fmt(&self, fmtr: &mut Formatter) -> Result<(), Error>

impl Debug for Force

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OsError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WindowAttributes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for EventLoopProxy<T> where
    T: 'static, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DeviceId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for EventLoopWindowTarget<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TranslatedCoords

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Event<'a, T> where
    T: 'static + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LogicalFrameExtents

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for LogicalSize<P> where
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MouseScrollDelta

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StartCause

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyboardInput

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Touch

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for PhysicalPosition<P> where
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BadIcon

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MonitorHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for LogicalPosition<P> where
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for EventLoopClosed<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AaRect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ControlFlow

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Fullscreen

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Geometry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MonitorHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GetPropertyError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Theme

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StateOperation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for WindowEvent<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VirtualKeyCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WindowType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModifierKeyState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PropMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CursorIcon

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XConnection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TouchPhase

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ElementState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VideoMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModifierKeymap

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FrameExtents

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FrameExtentsHeuristic

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FrameExtentsHeuristicPath

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModifiersState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for EventLoop<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for PhysicalSize<P> where
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitTimeoutResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Condvar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Once

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OnceState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for RwLock<R, T> where
    R: RawRwLock,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, G, T> Debug for ReentrantMutexGuard<'a, R, G, T> where
    G: 'a + GetThreadId,
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockReadGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MutexGuard<'a, R, T> where
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockReadGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, G, T> Debug for ReentrantMutex<R, G, T> where
    G: GetThreadId,
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockUpgradableReadGuard<'a, R, T> where
    R: 'a + RawRwLockUpgrade,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockWriteGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for Mutex<R, T> where
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, G, T> Debug for MappedReentrantMutexGuard<'a, R, G, T> where
    G: 'a + GetThreadId,
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedMutexGuard<'a, R, T> where
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockWriteGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, S> Debug for ScopeGuard<T, F, S> where
    F: FnOnce(T),
    S: Strategy,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Always

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RequeueOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CollectionAllocErr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Array,
    <T as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XcbHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RawWindowHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaylandHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XlibHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModifiersState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutputInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'lib, T> Debug for Symbol<'lib, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Library

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Symbol<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Library

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sides

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Endian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_> Debug for ScaledGlyph<'_>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlyphId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CacheWriteErr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<N> Debug for Rect<N> where
    N: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Scale

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SharedGlyphData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<N> Debug for Point<N> where
    N: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CachedBy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SharedBytes<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<N> Debug for Vector<N> where
    N: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CacheReadErr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HMetrics

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Codepoint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Contour

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CacheBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Curve

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Segment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VMetrics

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_> Debug for Glyph<'_>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for FontCollection<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_> Debug for Font<'_>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Line

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_> Debug for PositionedGlyph<'_>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FloatIsNan

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for OrderedFloat<T> where
    T: Debug + FloatCore, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for NotNan<T> where
    T: Debug + FloatCore, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for ParseNotNanError<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, S> Debug for LinkedHashMap<A, B, S> where
    A: Eq + Debug + Hash,
    B: Debug,
    S: BuildHasher, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Returns a string that lists the key-value pairs in insertion order.

impl<T> Debug for Stealer<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Worker<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Steal<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Injector<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Atomic<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Guard

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'g, T> Debug for Shared<'g, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Owned<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Collector

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'g, T, P> Debug for CompareAndSetError<'g, T, P> where
    P: Pointer<T> + Debug,
    T: 'g, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope, T> Debug for ScopedJoinHandle<'scope, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ShardedLock<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'env> Debug for Scope<'env>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockReadGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope, 'env> Debug for ScopedThreadBuilder<'scope, 'env> where
    'env: 'scope, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Backoff

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockWriteGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitGroup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CachePadded<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AtomicCell<T> where
    T: Copy + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unparker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MacLang

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PlatformId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rect<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VertexType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Data> Debug for FontInfo<Data> where
    Data: Deref<Target = [u8]> + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MacEid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Vertex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VMetrics

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnicodeEid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MicrosoftEid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Data> Debug for FontNameIter<'a, Data> where
    Data: Deref<Target = [u8]> + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HMetrics

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MicrosoftLang

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PlatformEncodingLanguageId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IntoIter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WalkDir

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, P> Debug for FilterEntry<I, P> where
    I: Debug,
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DirEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BaseDirectories

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BaseDirectoriesError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NamespaceStack

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Attribute<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Namespace

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EmitterConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParserConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OwnedAttribute

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for XmlEvent<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TextPosition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XmlVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Name<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OwnedName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XmlEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EmitterError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MmapMut

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Mmap

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for MmapOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MapFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RcvBufForce

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigmaskHow

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ForkptyResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReuseAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlushArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6MembershipRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for AioCb<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SendTimeout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlgSetAeadAuthSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PassCred

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FdFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ForkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Uid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AccessFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpKeepIdle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SfdFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlgAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpTransparent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimeVal

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for InetAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv4Addr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpCongestion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LioMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for LioCb<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Request

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigHandler

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CloneFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMulticastLoop

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollCreateFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NetlinkAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Whence

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6RecvPacketInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PeerCredentials

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignalFd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv4PacketInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptConn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SaFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DeleteModuleFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlowArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReceiveTimestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Errno

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FallocateFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PtyMaster

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RebootMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'d> Debug for Iter<'d>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UtimensatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LioOpcode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LinkAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MlockAllFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EfdFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InitFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemFdCreateFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaValidFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dir

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpDropMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OobInline

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReceiveTimeout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SealFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OriginalDst

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FchownatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigEvent

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Gid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SocketError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Broadcast

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MntFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SysconfVar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AioCancelStat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMulticastTtl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Buffer<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SockFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6DropMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6Addr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RcvBuf

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigevNotify

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SndBuf

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleInitFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReusePort

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMembershipRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsgFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MmapAdvise

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Inotify

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeepAlive

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpliceFFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SndBufForce

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ControlFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceAddressIterator

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FdFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AlgSetKey<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceAddress

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Options

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollFd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixCredentials

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InputFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Linger

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AtFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AioFsyncMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimeSpec

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for BaudRate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Entry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpecialCharacterIndices

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FchmodatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddressFamily

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpAddMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpNoDelay

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProtFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mark

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6AddMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddWatchFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WatchDescriptor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutputFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockProtocol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PathconfVar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitPidFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MQ_OFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaFmt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlobalError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AxisSource

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Transform

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Subpixel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FullscreenMethod

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Axis

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeymapFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Resize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DndAction

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Format

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProtocolError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Transient

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Capability

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ConnectError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ButtonState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for InsertError<E>

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Ready

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SetReadiness

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Poll

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Events

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollOpt

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for UnixReady

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Token

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for EventedFd<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Iter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UdpSocket

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Registration

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UdpBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timeout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LazyCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AtomicLazyCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MessageParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Message

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ArgumentType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Argument

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MessageWriteError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Source

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ButtonState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChangeCause

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CancelReason

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Layer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ButtonState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gravity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PresentMethod

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentHint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Anchor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ConstraintAdjustment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Flags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ConstraintAdjustment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Flags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Lifetime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for State

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PreeditStyle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentPurpose

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Anchor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for State

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Capability

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Capability

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TextDirection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentPurpose

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResizeEdge

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gravity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResizeEdge

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ButtonState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResizeEdge

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Anchor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentHint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Flags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for State

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for State

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Capability

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Kind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Source

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PercentDecode<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Symbol<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'lib, T> Debug for Symbol<'lib, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Library

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Library

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LoadingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ArbitraryTuplType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for HDRAdapter<R> where
    R: BufRead + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LimitErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Frame

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P, Container> Debug for ImageBuffer<P, Container> where
    Container: Debug,
    P: Pixel + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BitmapHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RGBE8Pixel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Luma<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnsupportedErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ArbitraryHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Bgr<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Buffer> Debug for FlatSamples<Buffer> where
    Buffer: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DXTVariant

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnsupportedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Progress

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LumaA<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SampleLayout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PNMSubtype

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GraymapHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Buffer, P> Debug for View<Buffer, P> where
    Buffer: Debug + AsRef<[<P as Pixel>::Subpixel]>,
    P: Pixel + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Bgra<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixelDensity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rgba<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParameterError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HDRMetadata

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rgb<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExtendedColorType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NormalForm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixelDensityUnit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParameterErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SampleEncoding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LimitError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EncodingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Buffer, P> Debug for ViewMut<Buffer, P> where
    Buffer: Debug + AsMut<[<P as Pixel>::Subpixel]>,
    P: Pixel + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for HdrDecoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixmapHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Delay

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageOutputFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Rect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageFormatHint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResolutionUnit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PhotometricInterpretation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Limits

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InflateError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodingResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Entry

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug + Read + Seek, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TiffError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TiffFormatError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Predictor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PlanarConfiguration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TiffUnsupportedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionMethod

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for DecoderEarlyChange<R> where
    R: BitReader + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: BitReader + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsbReader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LsbReader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MZFlush

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DataFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TINFLStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MZStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MZError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TDEFLFlush

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TDEFLStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionStrategy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamingDecoder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Block

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemoryLimit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorOutput

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DisposalMethod

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Frame<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Extension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Extensions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Decoded<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Ratio<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseRatioError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnsupportedFeature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixelFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Flatten<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for Bytes<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch, P> Debug for Matches<'ch, P> where
    P: Pattern + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Chain<A, B> where
    A: Debug + ParallelIterator,
    B: Debug + ParallelIterator<Item = <A as ParallelIterator>::Item>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, P> Debug for FilterMap<I, P> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Iter> Debug for IterBridge<Iter> where
    Iter: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Ord + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for Chunks<'data, T> where
    T: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Iter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RepeatN<T> where
    T: Clone + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for Chars<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, INIT, F> Debug for MapInit<I, INIT, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Empty<T> where
    T: Send, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Ord + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<U, I, ID, F> Debug for TryFold<I, U, ID, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Cloned<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for WhileSome<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for Windows<'data, T> where
    T: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Ord + Send + Debug,
    V: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch, P> Debug for MatchIndices<'ch, P> where
    P: Pattern + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, U, F> Debug for TryFoldWith<I, U, F> where
    I: ParallelIterator + Debug,
    U: Try,
    <U as Try>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for MaxLen<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Repeat<T> where
    T: Clone + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for CharIndices<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for Map<I, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Skip<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Take<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Enumerate<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for IterMut<'a, K, V> where
    K: Ord + Sync + Debug,
    V: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, U, F> Debug for FoldWith<I, U, F> where
    I: ParallelIterator + Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for InterleaveShortest<I, J> where
    I: Debug + IndexedParallelIterator,
    J: Debug + IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for Update<I, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for SplitWhitespace<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Eq + Send + Debug + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for Iter<'data, T> where
    T: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for Inspect<I, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for MinLen<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Eq + Sync + Debug + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for FlatMap<I, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for Iter<'a, K, V> where
    K: Ord + Sync + Debug,
    V: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for StepBy<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for Lines<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Ord + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Once<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Zip<A, B> where
    A: IndexedParallelIterator + Debug,
    B: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for ChunksMut<'data, T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for Interleave<I, J> where
    I: Debug + IndexedParallelIterator,
    J: Debug + IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for EncodeUtf16<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Rev<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, ID, F> Debug for Fold<I, ID, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, T, F> Debug for MapWith<I, T, F> where
    I: ParallelIterator + Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for ChunksExact<'data, T> where
    T: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, P> Debug for Filter<I, P> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Chunks<I> where
    I: Debug + IndexedParallelIterator, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D, S> Debug for Split<D, S> where
    D: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch, P> Debug for SplitTerminator<'ch, P> where
    P: Pattern + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T, P> Debug for SplitMut<'data, T, P> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for Iter<'a, K, V> where
    K: Eq + Sync + Debug + Hash,
    V: Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Copied<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T, P> Debug for Split<'data, T, P> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for IterMut<'data, T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for IterMut<'a, K, V> where
    K: Eq + Sync + Debug + Hash,
    V: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Intersperse<I> where
    I: Debug + ParallelIterator,
    <I as ParallelIterator>::Item: Clone,
    <I as ParallelIterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Eq + Send + Debug + Hash,
    V: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for ZipEq<A, B> where
    A: IndexedParallelIterator + Debug,
    B: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Ord + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Iter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for ChunksExactMut<'data, T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch, P> Debug for Split<'ch, P> where
    P: Pattern + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for MultiZip<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for PanicFuse<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<L, R> Debug for Either<L, R> where
    L: Debug,
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPoolBuildError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FnContext

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope> Debug for ScopeFifo<'scope>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPool

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Configuration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for ThreadPoolBuilder<S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope> Debug for Scope<'scope>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for PushError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ArrayQueue<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PopError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SegQueue<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Transformations

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Info

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FrameControl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BitDepth

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Decoded

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DisposeOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutputInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Compression

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixelDimensions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EncodingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Limits

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BlendOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnimationControl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MatchingType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Compression

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpecialOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Hasher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PodCastError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for BltFilter<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecoderError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SineWave

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Pausable<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for PeriodicAccess<I, F> where
    F: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Zero<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for TakeDuration<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for FadeIn<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Speed<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Empty<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Delay<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Spatial<I> where
    I: Debug + Source,
    <I as Iterator>::Item: Sample,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Amplify<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Done<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Stoppable<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for ChannelVolume<I> where
    I: Debug + Source,
    <I as Iterator>::Item: Sample,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlacReaderOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SupportedFormatsError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SupportedFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HostId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HostUnavailable

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SampleRate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Format

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DeviceNameError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PauseStreamError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PlayStreamError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BuildStreamError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Device

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BackendSpecificError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultFormatError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DevicesError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Host

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SampleFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _snd_pcm_audio_tstamp_config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _snd_pcm_audio_tstamp_report

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Storage, Align> Debug for __BindgenBitfieldUnit<Storage, Align> where
    Align: Debug,
    Storage: Debug + AsRef<[u8]> + AsMut<[u8]>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SampleFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WavSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AudioReadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HeaderReadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CommentHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VorbisError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for TinyVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for TinyVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OggReadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Frame

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for __fsid_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for mp3dec_frame_info_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AllocError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SliceDeque<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T, F> Debug for DrainFilter<'a, T, F> where
    F: Debug + FnMut(&mut T) -> bool,
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, I> Debug for Splice<'a, I> where
    I: 'a + Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RawEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Op

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecursiveMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DebouncedEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FileTime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Event<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WatchDescriptor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EventMask

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WatchMask

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for inotify_event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Loading content...

Implementors

impl Debug for geng_core::Event

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for geng_core::Key

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for geng_core::MouseButton

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for geng_core::prelude::bincode::ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BernoulliError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WeightedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Schema

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for c_void

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::io::ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SeekFrom

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LevelFilter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IndexVec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IndexVecIntoIter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::serde_json::Value

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Category

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AppSettings

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ArgSettings

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::structopt::clap::ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shell

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TexturedVertex

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for geng_core::draw_2d::Vertex

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for geng_core::obj::Vertex

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for geng_core::prelude::anyhow::Error

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::bincode::Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Alphanumeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bernoulli

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Beta

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Binomial

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Cauchy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChiSquared

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dirichlet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FisherF

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gamma

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LogNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Normal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Open01

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenClosed01

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pareto

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Poisson

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Standard

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StandardNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StudentT

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Triangular

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnitCircle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnitSphereSurface

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Weibull

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::channel::mpsc::SendError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::channel::mpsc::TryRecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Canceled

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Enter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EnterError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalSpawner

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::executor::ThreadPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::executor::ThreadPoolBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AbortHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AbortRegistration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Aborted

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::io::Empty

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::io::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::io::Repeat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::futures::io::Sink

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AtomicWaker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RawWaker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RawWakerVTable

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpawnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Waker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseLevelError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetLoggerError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UniformDuration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StepRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EntropyRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OsRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::rand::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IgnoredAny

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::serde::de::value::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompactFormatter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::serde_json::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::serde_json::Map<String, Value>

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::serde_json::Number

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Field

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::Name

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StdRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Struct

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::ThreadPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for geng_core::prelude::structopt::clap::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TouchPoint

fn fmt(&self, f: &mut Formatter) -> Result

impl<'_> Debug for geng_core::prelude::futures::task::Context<'_>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for FutureObj<'_, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for LocalFutureObj<'_, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for geng_core::prelude::futures::lock::MutexGuard<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for MutexLockFuture<'_, T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for Ref<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for RefMut<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for IndexVecIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for IoSlice<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for IoSliceMut<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for WakerRef<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for geng_core::prelude::log::Metadata<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for MetadataBuilder<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Record<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for RecordBuilder<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ArgGroup<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ArgMatches<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for OsValues<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SubCommand<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for geng_core::prelude::structopt::clap::Values<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for geng_core::prelude::futures::prelude::stream::futures_unordered::IterMut<'a, Fut> where
    Fut: Unpin + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinMut<'a, Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for Read<'a, R> where
    R: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadExact<'a, R> where
    R: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadLine<'a, R> where
    R: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadToEnd<'a, R> where
    R: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadToString<'a, R> where
    R: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadUntil<'a, R> where
    R: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadVectored<'a, R> where
    R: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, W> Debug for CopyBufInto<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, W> Debug for CopyInto<'a, R, W> where
    R: Debug + AsyncRead,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for Seek<'a, S> where
    S: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S, T> Debug for SliceChooseIter<'a, S, T> where
    S: 'a + Debug + ?Sized,
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Si, Item> Debug for geng_core::prelude::futures::prelude::sink::Close<'a, Si, Item> where
    Item: Debug,
    Si: Unpin + Debug + Sink<Item> + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Si, Item> Debug for geng_core::prelude::futures::prelude::sink::Flush<'a, Si, Item> where
    Item: Debug,
    Si: Unpin + Debug + Sink<Item> + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Si, Item> Debug for Send<'a, Si, Item> where
    Item: Debug,
    Si: Unpin + Debug + Sink<Item> + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Si, St> Debug for SendAll<'a, Si, St> where
    Si: Debug + Sink<<St as Stream>::Item> + Unpin + ?Sized,
    St: Debug + Stream + Unpin + ?Sized,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for Next<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for SelectNextSome<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for TryNext<'a, St> where
    St: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for geng_core::prelude::futures::io::Close<'a, W> where
    W: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for geng_core::prelude::futures::io::Flush<'a, W> where
    W: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for Write<'a, W> where
    W: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for WriteAll<'a, W> where
    W: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for WriteVectored<'a, W> where
    W: Unpin + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for geng_core::prelude::futures::future::Either<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for geng_core::prelude::futures::future::Select<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for TrySelect<A, B> where
    A: Unpin + Debug,
    B: Unpin + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D, R, T> Debug for DistIter<D, R, T> where
    D: Debug,
    R: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I128Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U128Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for JoinAll<F> where
    F: Future + Debug,
    <F as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for geng_core::prelude::futures::future::Lazy<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for OptionFuture<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for geng_core::prelude::futures::future::PollFn<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for TryJoinAll<F> where
    F: TryFuture + Debug,
    <F as TryFuture>::Ok: Debug,
    <F as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for geng_core::prelude::futures::prelude::stream::PollFn<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for MaybeDone<Fut> where
    Fut: Debug + Future,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Abortable<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for geng_core::prelude::futures::future::CatchUnwind<Fut> where
    Fut: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for geng_core::prelude::futures::future::Flatten<Fut> where
    Fut: Future + Debug,
    <Fut as Future>::Output: Future,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FlattenStream<Fut> where
    Fut: Future + Debug,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for geng_core::prelude::futures::future::Fuse<Fut> where
    Fut: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for IntoFuture<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for geng_core::prelude::futures::future::IntoStream<Fut> where
    Fut: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for NeverError<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Remote<Fut> where
    Fut: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for geng_core::prelude::futures::future::SelectAll<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for SelectOk<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for geng_core::prelude::futures::future::Shared<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for TryFlattenStream<Fut> where
    Fut: TryFuture + Debug,
    <Fut as TryFuture>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for UnitError<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FuturesOrdered<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FuturesUnordered<Fut>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for geng_core::prelude::futures::prelude::stream::Once<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, E> Debug for geng_core::prelude::futures::future::ErrInto<Fut, E> where
    E: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for geng_core::prelude::futures::future::Inspect<Fut, F> where
    F: Debug,
    Fut: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for geng_core::prelude::futures::future::InspectErr<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for geng_core::prelude::futures::future::InspectOk<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for geng_core::prelude::futures::future::Map<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for geng_core::prelude::futures::future::MapErr<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for geng_core::prelude::futures::future::MapOk<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for UnwrapOrElse<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, Si> Debug for FlattenSink<Fut, Si> where
    Fut: Debug + TryFuture<Ok = Si>,
    Si: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2> Debug for Join<Fut1, Fut2> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2> Debug for TryJoin<Fut1, Fut2> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for geng_core::prelude::futures::future::AndThen<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for geng_core::prelude::futures::future::OrElse<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for geng_core::prelude::futures::future::Then<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for Join3<Fut1, Fut2, Fut3> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for TryJoin3<Fut1, Fut2, Fut3> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for Join4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for TryJoin4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for Join5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    Fut5: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug,
    <Fut5 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for TryJoin5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    Fut5: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug,
    <Fut5 as TryFuture>::Ok: Debug,
    <Fut5 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for geng_core::prelude::futures::prelude::stream::Iter<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Idx> Debug for geng_core::prelude::Range<Idx> where
    Idx: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Idx> Debug for RangeInclusive<Idx> where
    Idx: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<K, V, S> Debug for geng_core::prelude::HashMap<K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for Pin<P> where
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for geng_core::prelude::futures::io::BufReader<R> where
    R: Debug + AsyncRead, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for geng_core::prelude::futures::io::Lines<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for geng_core::prelude::futures::io::Take<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for ReadRng<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for BlockingStream<S> where
    S: Unpin + Debug + Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for SplitStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, Item> Debug for SplitSink<S, Item> where
    Item: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si, F> Debug for SinkMapErr<Si, F> where
    F: Debug,
    Si: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si, Item> Debug for geng_core::prelude::futures::prelude::sink::Buffer<Si, Item> where
    Item: Debug,
    Si: Debug + Sink<Item>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si, Item, E> Debug for SinkErrInto<Si, Item, E> where
    E: Debug,
    Item: Debug,
    Si: Debug + Sink<Item>,
    <Si as Sink<Item>>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si, Item, U, Fut, F> Debug for With<Si, Item, U, Fut, F> where
    Fut: Debug,
    Item: Debug,
    Si: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si, Item, U, St, F> Debug for WithFlatMap<Si, Item, U, St, F> where
    Item: Debug,
    Si: Sink<Item> + Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si1, Si2> Debug for Fanout<Si1, Si2> where
    Si1: Debug,
    Si2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for BufferUnordered<St> where
    St: Stream + Debug,
    <St as Stream>::Item: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Buffered<St> where
    St: Stream + Debug,
    <St as Stream>::Item: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::CatchUnwind<St> where
    St: Debug + Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::Chunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Concat<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::Enumerate<St> where
    St: Debug + Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::Flatten<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::Fuse<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for IntoAsyncRead<St> where
    St: Debug + TryStream<Error = Error> + Unpin,
    <St as TryStream>::Ok: AsRef<[u8]>,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::IntoStream<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::Peekable<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::SelectAll<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::Skip<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for StreamFuture<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for geng_core::prelude::futures::prelude::stream::Take<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryBufferUnordered<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryConcat<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryFlatten<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, C> Debug for Collect<St, C> where
    C: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, C> Debug for TryCollect<St, C> where
    C: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, E> Debug for geng_core::prelude::futures::prelude::stream::ErrInto<St, E> where
    E: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for geng_core::prelude::futures::prelude::stream::Inspect<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for geng_core::prelude::futures::prelude::stream::InspectErr<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for geng_core::prelude::futures::prelude::stream::InspectOk<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for geng_core::prelude::futures::prelude::stream::Map<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for geng_core::prelude::futures::prelude::stream::MapErr<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for geng_core::prelude::futures::prelude::stream::MapOk<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for geng_core::prelude::futures::prelude::stream::AndThen<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for geng_core::prelude::futures::prelude::stream::Filter<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for geng_core::prelude::futures::prelude::stream::FilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for geng_core::prelude::futures::prelude::stream::OrElse<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for geng_core::prelude::futures::prelude::stream::SkipWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for geng_core::prelude::futures::prelude::stream::TakeWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for geng_core::prelude::futures::prelude::stream::Then<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilter<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TrySkipWhile<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, T, F> Debug for geng_core::prelude::futures::prelude::stream::Fold<St, Fut, T, F> where
    Fut: Debug,
    St: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, T, F> Debug for geng_core::prelude::futures::prelude::stream::TryFold<St, Fut, T, F> where
    Fut: Debug,
    St: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Si> Debug for Forward<St, Si> where
    Si: Debug + Sink<<St as TryStream>::Ok>,
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for geng_core::prelude::futures::prelude::stream::Chain<St1, St2> where
    St1: Debug,
    St2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for geng_core::prelude::futures::prelude::stream::Select<St1, St2> where
    St1: Debug,
    St2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for geng_core::prelude::futures::prelude::stream::Zip<St1, St2> where
    St1: Debug + Stream,
    St2: Debug + Stream,
    <St1 as Stream>::Item: Debug,
    <St2 as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Bound<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::Poll<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::channel::mpsc::Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::channel::mpsc::Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::channel::mpsc::TrySendError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::channel::oneshot::Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::channel::oneshot::Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::future::Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::future::Ready<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RemoteHandle<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AllowStdIo<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::io::Window<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::lock::Mutex<T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::prelude::sink::Drain<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::prelude::stream::Empty<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::prelude::stream::Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::futures::prelude::stream::Repeat<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::once_cell::sync::OnceCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::once_cell::unsync::OnceCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AABB<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Cell<T> where
    T: Copy + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::Color<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Mat4<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for geng_core::prelude::Mutex<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for PhantomData<T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Quat<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rc<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RealImpl<T> where
    T: Float, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RefCell<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Vec2<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Vec3<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Vec4<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F> Debug for geng_core::prelude::once_cell::sync::Lazy<T, F> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F> Debug for geng_core::prelude::once_cell::unsync::Lazy<T, F> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    Fut: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, Item> Debug for ReuniteError<T, Item>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for geng_core::prelude::HashSet<T, S> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for geng_core::prelude::futures::io::Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for geng_core::prelude::futures::io::BufWriter<W> where
    W: Debug + AsyncWrite, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for geng_core::prelude::rand::distributions::weighted::alias_method::WeightedIndex<W> where
    W: Weight + Debug,
    Uniform<W>: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W, Item> Debug for IntoSink<W, Item> where
    Item: Debug,
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for Uniform<X> where
    X: SampleUniform + Debug,
    <X as SampleUniform>::Sampler: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for geng_core::prelude::distributions::WeightedIndex<X> where
    X: SampleUniform + PartialOrd<X> + Debug,
    <X as SampleUniform>::Sampler: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for UniformFloat<X> where
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for UniformInt<X> where
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Loading content...