Trait grafix_toolbox::uses::Debug

pub trait Debug {
    pub 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

pub 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, 

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

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

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

impl Debug for Ipv6MulticastScope

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

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

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

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

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

impl Debug for AncillaryError

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

impl Debug for Builder

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

impl<'a> Debug for CommandEnvs<'a>

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

impl<K, V, S> Debug for HashMap<K, V, S> where
    V: Debug,
    K: Debug, 

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

impl Debug for Permissions

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

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

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

impl Debug for IpAddr

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

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

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

impl<T, S> Debug for HashSet<T, S> where
    T: Debug, 

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

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

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

impl Debug for BacktraceFrame

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

impl Debug for TcpStream

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

impl Debug for Command

pub 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<'a> Debug for SocketAncillary<'a>

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

impl Debug for FromVecWithNulError

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

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

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

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

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

impl<T> Debug for Key<T>

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

impl Debug for BacktraceStatus

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

impl Debug for SocketAddrV6

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

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

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

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

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

impl Debug for Child

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

impl Debug for FromBytesWithNulError

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

impl Debug for Stdio

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

impl Debug for Shutdown

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

impl<T> Debug for JoinHandle<T>

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

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

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

impl Debug for ChildStdin

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

impl Debug for Vars

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

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

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

impl Debug for SocketAddrV4

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

impl Debug for UnixStream

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

impl Debug for VarsOs

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

impl Debug for OpenOptions

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

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

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

impl Debug for SocketAddr

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

impl Debug for DirEntry

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

impl Debug for UdpSocket

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

impl Debug for Backtrace

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

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

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

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

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

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

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

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

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

impl Debug for JoinPathsError

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

impl Debug for TcpListener

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

impl<'a> Debug for CommandArgs<'a>

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

impl Debug for ExitStatus

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

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

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

impl Debug for SocketAddr

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

impl Debug for OsString

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

impl Debug for UCred

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

impl Debug for Ipv4Addr

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

impl Debug for File

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

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

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

impl Debug for ThreadId

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

impl Debug for NulError

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

impl Debug for Ipv6Addr

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

impl Debug for Args

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

impl Debug for FileType

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

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

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

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

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

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

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

impl Debug for Metadata

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

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

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

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

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

impl Debug for DefaultHasher

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

impl Debug for AddrParseError

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

impl Debug for ChildStderr

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

impl Debug for System

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

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

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

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

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

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

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

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

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

impl Debug for OsStr

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

impl Debug for UnixDatagram

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

impl Debug for Output

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

impl Debug for Thread

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

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

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

impl Debug for ChildStdout

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

impl Debug for UnixListener

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

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

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

impl<T> Debug for Key<T>

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

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

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

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

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

impl Debug for ArgsOs

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

impl Debug for VarError

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

impl Debug for IntoStringError

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

impl Debug for ExitCode

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

impl Debug for CString

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

impl Debug for DirBuilder

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

impl Debug for AccessError

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

impl Debug for ReadDir

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

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

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

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

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

impl Debug for CStr

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

impl Debug for RandomState

pub 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

pub 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

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

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

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

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

pub 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

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

impl Debug for NoneError

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

impl Debug for __m128

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

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

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

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

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

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

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

impl Debug for PhantomPinned

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

impl Debug for EscapeDebug

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

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

pub 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

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

impl Debug for NonZeroI128

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

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

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

impl<'_> Debug for Context<'_>

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

impl Debug for dyn Any + 'static

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

impl Debug for FpCategory

pub 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

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

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

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

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

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

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

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

impl Debug for Utf8Error

pub 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

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

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

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

impl Debug for u16

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

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

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

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

pub 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, 

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

impl Debug for c_void

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

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

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

impl Debug for BorrowMutError

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

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

pub 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

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

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

pub 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

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

impl Debug for ParseFloatError

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

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

pub 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

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

impl<T, const N: usize> Debug for IntoIter<T, N> where
    T: Debug, 

pub 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

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

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

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

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

pub 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, 

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

impl Debug for IntErrorKind

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

impl Debug for Waker

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

impl Debug for bool

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

pub 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

pub 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

pub 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

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

impl Debug for NonZeroIsize

pub 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

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

impl Debug for f32

pub fn fmt(&self, fmt: &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
    T2: Debug,
    T3: Debug,
    T4: Debug,
    T5: Debug,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug,
    T10: Debug,
    T11: Debug + ?Sized, 

pub 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
    T1: Debug,
    T2: Debug,
    T3: Debug,
    T4: Debug,
    T0: Debug,
    T5: Debug,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug,
    T10: Debug,
    T11: Debug + ?Sized, 

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

impl Debug for dyn Any + 'static + Send

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

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

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

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

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

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

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

impl Debug for str

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

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

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

impl Debug for ToLowercase

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

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

pub 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

pub 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

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

impl Debug for TryFromIntError

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

impl Debug for __m128d

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

impl Debug for Utf8Lossy

pub 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, 

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

impl Debug for __m256

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

impl Debug for Infallible

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

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

pub 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

pub 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, 

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

impl Debug for u128

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

impl Debug for EscapeUnicode

pub 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, 

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

impl Debug for !

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

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

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

impl Debug for i16

pub 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

pub 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

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

impl Debug for char

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

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

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

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

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

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

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

impl Debug for LayoutError

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

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

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

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

pub 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

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

impl Debug for __m512

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

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

pub 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

pub 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

pub 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

pub 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, 

pub 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

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

impl Debug for f64

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

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

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

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

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

impl Debug for SearchStep

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

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

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

impl Debug for __m128i

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

impl Debug for ParseCharError

pub 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

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

impl Debug for Layout

pub 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

pub 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

pub 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

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

impl Debug for NonZeroI8

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

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

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

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

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

impl Debug for i32

pub 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

pub 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

pub 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

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

impl Debug for ToUppercase

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

impl Debug for BorrowError

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

impl Debug for isize

pub 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

pub 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

pub 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

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

impl Debug for i128

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

impl Debug for __m512i

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

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

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

impl Debug for CpuidResult

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

impl Debug for CharTryFromError

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

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

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

impl Debug for EscapeDefault

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

impl Debug for __m256i

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

impl Debug for usize

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroI32

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

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

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

impl Debug for u8

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

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

pub 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

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

impl Debug for RawWaker

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

impl Debug for i64

pub 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

pub 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, 

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

impl Debug for RawWakerVTable

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

impl<T> Debug for Pending<T>

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

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

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

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

pub 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

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

impl Debug for NonZeroUsize

pub 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, 

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

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

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

impl Debug for NonZeroU64

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

impl Debug for ParseBoolError

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

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

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

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

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

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

pub 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

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

impl Debug for ()

pub 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

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

impl Debug for __m512d

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

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

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

impl Debug for u32

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

impl Debug for NonZeroI16

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

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

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

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

impl Debug for ParseIntError

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

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

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

impl<P> Debug for Pin<P> where
    P: Debug, 

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

impl Debug for NonZeroU8

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

impl Debug for NonZeroU16

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

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

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

impl Debug for EscapeDefault

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

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

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

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

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

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

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

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

impl Debug for TryFromSliceError

pub 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, 

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

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

impl Debug for __m256d

pub 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

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

impl Debug for u64

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

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

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

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

pub 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

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

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

pub 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

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

impl<F> Debug for PollFn<F>

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TypeId

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

impl Debug for NonZeroI64

pub 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

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

impl Debug for AllocError

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

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

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

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

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

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

pub 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

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

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

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

impl Debug for NonZeroU32

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

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

pub 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

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroU128

pub 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

pub 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

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

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

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

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

pub 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

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

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

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

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

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

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

pub 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, 

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

impl Debug for DecodeUtf16Error

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

impl Debug for i8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TryReserveError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for String

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

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

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

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

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

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

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

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

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

impl Debug for FromUtf16Error

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

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

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

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

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

impl Debug for Global

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

impl Debug for FromUtf8Error

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

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

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

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

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

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

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

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

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

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

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

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

pub 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,
    V: Debug,
    K: Debug, 

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

impl Debug for _Unwind_Reason_Code

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

impl<'a> Debug for WindowMode<'a>

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

impl Debug for JoystickHats

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

impl Debug for Error

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

impl Debug for VidMode

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

Returns a string representation of the video mode.

Returns

A string in the form:

~"[width] x [height], [total_bits] ([red_bits] [green_bits] [blue_bits]) [refresh_rate] Hz"

impl Debug for OpenGlProfileHint

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

impl Debug for InitError

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

impl Debug for Cursor

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

impl Debug for SwapInterval

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

impl Debug for StandardCursor

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

impl Debug for MouseButton

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

impl Debug for MonitorEvent

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

impl Debug for ContextCreationApi

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

impl Debug for ClientApiHint

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

impl Debug for JoystickEvent

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

impl Debug for GamepadButton

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

impl Debug for Action

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

impl Debug for Glfw

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

impl Debug for DebugAliases<MouseButton>

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

impl Debug for WindowHint

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

impl Debug for Monitor

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

impl Debug for Window

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

impl Debug for CursorMode

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

impl Debug for Modifiers

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

impl Debug for JoystickId

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

impl Debug for ContextRobustnessHint

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

impl Debug for InitHint

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

impl Debug for GamepadAxis

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

impl Debug for WindowEvent

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

impl Debug for ContextReleaseBehavior

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

impl Debug for SemVerError

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

impl Debug for Identifier

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

impl Debug for Version

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

impl Debug for ReqParseError

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

impl Debug for VersionReq

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

impl Debug for Predicate

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

impl Debug for WildcardVersion

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

impl Debug for Identifier

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

impl Debug for Version

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

impl Debug for Op

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

impl Debug for VersionReq

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

impl<'a> Debug for MetadataBuilder<'a>

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

impl Debug for Level

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

impl<'a> Debug for Record<'a>

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

impl Debug for ParseLevelError

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

impl<'a> Debug for Metadata<'a>

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

impl Debug for LevelFilter

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

impl<'a> Debug for RecordBuilder<'a>

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

impl Debug for SetLoggerError

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

impl Debug for RawWindowHandle

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

impl Debug for XlibHandle

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

impl Debug for XcbHandle

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

impl Debug for WaylandHandle

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

impl<X> Debug for UniformFloat<X> where
    X: Debug, 

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

impl<X> Debug for WeightedIndex<X> where
    X: Debug + SampleUniform + PartialOrd<X>,
    <X as SampleUniform>::Sampler: Debug, 

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

impl Debug for IndexVecIntoIter

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

impl Debug for UniformDuration

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

impl Debug for IndexVec

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

impl<D, R, T> Debug for DistIter<D, R, T> where
    T: Debug,
    D: Debug,
    R: Debug, 

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

impl Debug for ReadError

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

impl Debug for Bernoulli

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

impl<W> Debug for WeightedIndex<W> where
    W: Debug + Weight, 

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

impl Debug for StdRng

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

impl Debug for BernoulliError

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

impl Debug for WeightedError

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

impl Debug for ThreadRng

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

impl Debug for Open01

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

impl Debug for OpenClosed01

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

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

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

impl<'a> Debug for IndexVecIter<'a>

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

impl Debug for StepRng

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

impl Debug for UniformChar

pub 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, 

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

impl<X> Debug for UniformInt<X> where
    X: Debug, 

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

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

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

impl Debug for Alphanumeric

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

impl Debug for Standard

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

impl Debug for OsRng

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

impl Debug for Error

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

impl<R> Debug for BlockRng64<R> where
    R: BlockRngCore + Debug, 

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

impl<R> Debug for BlockRng<R> where
    R: BlockRngCore + Debug, 

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

impl Debug for Error

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

impl Debug for ChaCha12Core

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

impl Debug for ChaCha8Rng

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

impl Debug for ChaCha12Rng

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

impl Debug for ChaCha20Rng

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

impl Debug for ChaCha20Core

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

impl Debug for ChaCha8Core

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

impl<'_> Debug for ScaledGlyph<'_>

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

impl<N> Debug for Vector<N> where
    N: Debug, 

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

impl Debug for GlyphId

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

impl Debug for HMetrics

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

impl<'_> Debug for Font<'_>

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

impl<'_> Debug for PositionedGlyph<'_>

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

impl<'_> Debug for Glyph<'_>

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

impl Debug for VMetrics

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

impl<N> Debug for Point<N> where
    N: Debug, 

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

impl Debug for Scale

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

impl<N> Debug for Rect<N> where
    N: Debug, 

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

impl Debug for OwnedFont

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

impl Debug for Width

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

impl Debug for ScriptMetrics

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

impl Debug for GlyphId

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

impl Debug for Weight

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

impl Debug for LineMetrics

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

impl Debug for Variation

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

impl<'_> Debug for Machine<'_>

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

impl Debug for RasterImageFormat

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

impl Debug for VariationAxis

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

impl<'_> Debug for Font<'_>

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

impl<'a> Debug for RasterGlyphImage<'a>

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

impl Debug for Class

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

impl Debug for Rect

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

impl Debug for ValueOffset

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

impl Debug for GlyphClass

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

impl Debug for Tag

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

impl Debug for TableName

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

impl Debug for State

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

impl<'_> Debug for Subtable<'_>

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

impl<'a> Debug for Name<'a>

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

impl Debug for Entry

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

impl Debug for PlatformId

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

impl Debug for Point

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

impl Debug for Rasterizer

let rasterizer = ab_glyph_rasterizer::Rasterizer::new(3, 4);
assert_eq!(&format!("{:?}", rasterizer), "Rasterizer { width: 3, height: 4 }");

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

impl Debug for UnsupportedError

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

impl Debug for ParameterErrorKind

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

impl<R> Debug for HdrAdapter<R> where
    R: Debug + BufRead, 

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

impl<'a, I> Debug for Pixels<'a, I> where
    I: 'a + Debug + ?Sized, 

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

impl Debug for Rect

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

impl Debug for Error

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

impl<'_, P> Debug for EnumeratePixels<'_, P> where
    P: Pixel,
    <P as Pixel>::Subpixel: Debug, 

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

impl Debug for ImageFormatHint

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

impl Debug for ColorType

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

impl Debug for SampleLayout

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

impl<'_, P> Debug for PixelsMut<'_, P> where
    P: Pixel,
    <P as Pixel>::Subpixel: Debug, 

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

impl Debug for ImageOutputFormat

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

impl<T> Debug for Rgb<T> where
    T: Debug + Primitive, 

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

impl Debug for UnsupportedErrorKind

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

impl Debug for HdrMetadata

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

impl Debug for CompressionType

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

impl Debug for EncodingError

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

impl Debug for ExtendedColorType

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

impl<'_, P> Debug for EnumeratePixelsMut<'_, P> where
    P: Pixel,
    <P as Pixel>::Subpixel: Debug, 

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

impl Debug for ParameterError

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

impl<'_, P> Debug for RowsMut<'_, P> where
    P: Pixel,
    <P as Pixel>::Subpixel: Debug, 

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

impl Debug for FilterType

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

impl Debug for ImageFormat

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

impl Debug for FilterType

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

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

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

impl<Buffer> Debug for FlatSamples<Buffer> where
    Buffer: Debug, 

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

impl<P, Container> Debug for ImageBuffer<P, Container> where
    P: Debug + Pixel,
    Container: Debug, 

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

impl<'_, P> Debug for EnumerateRows<'_, P> where
    P: Pixel,
    <P as Pixel>::Subpixel: Debug, 

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

impl<T> Debug for Bgr<T> where
    T: Debug + Primitive, 

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

impl<'_, P> Debug for Pixels<'_, P> where
    P: Pixel,
    <P as Pixel>::Subpixel: Debug, 

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

impl Debug for LimitError

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

impl Debug for ImageError

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

impl<T> Debug for Luma<T> where
    T: Debug + Primitive, 

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

impl Debug for LimitErrorKind

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

impl<Buffer, P> Debug for View<Buffer, P> where
    P: Debug + Pixel,
    Buffer: Debug + AsRef<[<P as Pixel>::Subpixel]>, 

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

impl Debug for Rgbe8Pixel

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

impl<Buffer, P> Debug for ViewMut<Buffer, P> where
    P: Debug + Pixel,
    Buffer: Debug + AsMut<[<P as Pixel>::Subpixel]>, 

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

impl<'_, P> Debug for Rows<'_, P> where
    P: Pixel,
    <P as Pixel>::Subpixel: Debug, 

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

impl<T> Debug for Rgba<T> where
    T: Debug + Primitive, 

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

impl<'_, P> Debug for EnumerateRowsMut<'_, P> where
    P: Pixel,
    <P as Pixel>::Subpixel: Debug, 

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

impl Debug for DecodingError

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

impl Debug for Progress

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

impl Debug for Delay

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

impl Debug for NormalForm

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

impl Debug for DynamicImage

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

impl<T> Debug for Bgra<T> where
    T: Debug + Primitive, 

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

impl<T> Debug for LumaA<T> where
    T: Debug + Primitive, 

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

impl Debug for FloatErrorKind

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

impl Debug for ParseFloatError

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

impl Debug for BigEndian

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

impl Debug for LittleEndian

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

impl Debug for ParseRatioError

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

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

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

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

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

impl Debug for PixelDimensions

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

impl Debug for Compression

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

impl Debug for BlendOp

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

impl Debug for Unit

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

impl Debug for DisposeOp

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

impl Debug for FrameControl

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

impl Debug for Info

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

impl Debug for Transformations

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

impl Debug for Decoded

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

impl Debug for OutputInfo

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

impl Debug for AnimationControl

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

impl Debug for EncodingError

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

impl Debug for FilterType

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

impl Debug for ColorType

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

impl Debug for Limits

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

impl Debug for BitDepth

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

impl Debug for DecodingError

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

impl Debug for CompressionOptions

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

impl Debug for Compression

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

impl Debug for MatchingType

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

impl Debug for SpecialOptions

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

impl Debug for Hasher

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

impl Debug for DataFormat

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

impl Debug for TDEFLStatus

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

impl Debug for TINFLStatus

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

impl Debug for MZStatus

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

impl Debug for MZError

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

impl Debug for MZFlush

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

impl Debug for TDEFLFlush

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

impl Debug for CompressionLevel

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

impl Debug for StreamResult

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

impl Debug for CompressionStrategy

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

impl Debug for PodCastError

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

impl Debug for bf16

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

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

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

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

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

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

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

impl<'_, K, V, A> Debug for Drain<'_, K, V, A> where
    A: Allocator + Clone,
    V: Debug,
    K: Debug, 

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

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

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

impl<'_, K, V, S, A> Debug for RawEntryBuilderMut<'_, K, V, S, A> where
    A: Allocator + Clone, 

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

impl<K, A> Debug for IntoIter<K, A> where
    A: Allocator + Clone,
    K: Debug, 

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

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

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

impl Debug for TryReserveError

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

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

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

impl<'_, K, V, S, A> Debug for OccupiedEntry<'_, K, V, S, A> where
    A: Allocator + Clone,
    V: Debug,
    K: Debug, 

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

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

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

impl<'_, K, V, S, A> Debug for VacantEntry<'_, K, V, S, A> where
    A: Allocator + Clone,
    K: Debug, 

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

impl<'_, K, V, S, A> Debug for Entry<'_, K, V, S, A> where
    A: Allocator + Clone,
    V: Debug,
    K: Debug, 

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

impl<'_, K, V, S, A> Debug for RawOccupiedEntryMut<'_, K, V, S, A> where
    A: Allocator + Clone,
    V: Debug,
    K: Debug, 

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

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

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

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

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

impl<'_, K, V, S, A> Debug for RawEntryBuilder<'_, K, V, S, A> where
    A: Allocator + Clone, 

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

impl<'_, K, A> Debug for Drain<'_, K, A> where
    A: Allocator + Clone,
    K: Debug, 

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

impl<'_, K, V, S, A> Debug for RawEntryMut<'_, K, V, S, A> where
    A: Allocator + Clone,
    V: Debug,
    K: Debug, 

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

impl<'_, K, V, S, A> Debug for OccupiedError<'_, K, V, S, A> where
    A: Allocator + Clone,
    V: Debug,
    K: Debug, 

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

impl<K, V, A> Debug for IntoIter<K, V, A> where
    A: Allocator + Clone,
    V: Debug,
    K: Debug, 

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

impl<'_, K, V, S, A> Debug for RawVacantEntryMut<'_, K, V, S, A> where
    A: Allocator + Clone, 

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

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

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

impl Debug for RandomState

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

impl Debug for AHasher

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

impl Debug for OnceBool

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

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

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

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

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

impl Debug for OnceNonZeroUsize

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

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

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

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

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

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

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

impl<'a> Debug for Executor<'a>

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

impl<'a> Debug for LocalExecutor<'a>

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

impl Debug for Runnable

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

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

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

impl Debug for PopError

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

impl<T> Debug for ConcurrentQueue<T>

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

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

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

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

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

impl<S1, S2> Debug for Race<S1, S2> where
    S1: Debug,
    S2: Debug, 

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

impl<F> Debug for PollOnce<F>

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

impl<'a, S, P> Debug for AllFuture<'a, S, P> where
    S: Debug + ?Sized,
    P: Debug, 

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

impl<S, F, T> Debug for FoldFuture<S, F, T> where
    S: Debug,
    T: Debug,
    F: Debug, 

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

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

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

impl<S, F> Debug for ForEachFuture<S, F> where
    S: Debug,
    F: Debug, 

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

impl<'a, S, P> Debug for FindFuture<'a, S, P> where
    S: Debug + ?Sized,
    P: Debug, 

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

impl<F1, F2> Debug for Or<F1, F2> where
    F1: Debug,
    F2: Debug, 

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

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

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

impl<T, F, Fut> Debug for TryUnfold<T, F, Fut> where
    T: Debug,
    Fut: Debug, 

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

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

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

impl<S> Debug for BlockOn<S> where
    S: Debug, 

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

impl<A, B> Debug for Zip<A, B> where
    A: Debug + Stream,
    B: Debug,
    <A as Stream>::Item: Debug, 

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

impl<S> Debug for Flatten<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

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

impl<F1, F2> Debug for TryZip<F1, F2> where
    F1: Debug + Future,
    F2: Debug + Future,
    <F1 as Future>::Output: Debug,
    <F2 as Future>::Output: Debug, 

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

impl<S, U, F> Debug for FlatMap<S, U, F> where
    S: Debug,
    F: Debug,
    U: Debug, 

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

impl Debug for YieldNow

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

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

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

impl<S, FromA, FromB> Debug for UnzipFuture<S, FromA, FromB> where
    S: Debug,
    FromA: Debug,
    FromB: Debug, 

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

impl<F1, F2> Debug for Zip<F1, F2> where
    F1: Debug + Future,
    F2: Debug + Future,
    <F1 as Future>::Output: Debug,
    <F2 as Future>::Output: Debug, 

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

impl<'a, S, P> Debug for AnyFuture<'a, S, P> where
    S: Debug + ?Sized,
    P: Debug, 

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

impl<'a, S> Debug for NthFuture<'a, S> where
    S: Debug + ?Sized, 

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

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

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

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    T: Debug,
    Fut: Debug, 

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

impl<S, C> Debug for TryCollectFuture<S, C> where
    C: Debug,
    S: Debug, 

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

impl<F> Debug for PollFn<F>

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

impl<F> Debug for PollFn<F>

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

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

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

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

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

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

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

impl<S> Debug for LastFuture<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

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

impl<T> Debug for Pending<T>

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

impl<S, F, Fut> Debug for Then<S, F, Fut> where
    S: Debug,
    F: Debug,
    Fut: Debug, 

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

impl<'a, S, F> Debug for FindMapFuture<'a, S, F> where
    S: Debug + ?Sized,
    F: Debug, 

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

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

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

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

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

impl<'a, S, P> Debug for PositionFuture<'a, S, P> where
    S: Debug + ?Sized,
    P: Debug, 

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

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

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F1, F2> Debug for Race<F1, F2> where
    F1: Debug,
    F2: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, C> Debug for CollectFuture<S, C> where
    C: Debug,
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Once<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Cloned<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, P> Debug for TakeWhile<S, P> where
    S: Debug,
    P: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, P> Debug for SkipWhile<S, P> where
    S: Debug,
    P: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Iter<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Cycle<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S, F, B> Debug for TryFoldFuture<'a, S, F, B> where
    S: Debug,
    B: Debug,
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S, F> Debug for TryForEachFuture<'a, S, F> where
    S: Debug + ?Sized,
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Enumerate<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for CatchUnwind<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for CountFuture<S> where
    S: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, P, B> Debug for PartitionFuture<S, P, B> where
    S: Debug,
    B: Debug,
    P: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, U> Debug for Chain<S, U> where
    S: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for StepBy<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for TryNextFuture<'a, S> where
    S: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, St, F> Debug for Scan<S, St, F> where
    S: Debug,
    F: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for NextFuture<'a, S> where
    S: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S1, S2> Debug for Or<S1, S2> where
    S1: Debug,
    S2: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Repeat<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Unparker

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parker

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Rng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Arena<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Async<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Timer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Event

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Poller

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Protocol

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Type

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SockAddr

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Domain

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Socket

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Recv<'a, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Send<'a, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EventListener

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Event

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicWaker

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DirBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for File

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DirEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpenOptions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReadDir

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Incoming<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixStream

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Incoming<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixListener

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixDatagram

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UdpSocket

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpStream

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpListener

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChildStdout

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChildStderr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Command

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChildStdin

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Child

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WithRawSiginfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Handle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Pending<E> where
    E: Debug + Exfiltrator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, E> Debug for SignalDelivery<R, E> where
    E: Debug + Exfiltrator,
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SignalsInfo<E> where
    E: Debug + Exfiltrator,
    <E as Exfiltrator>::Storage: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SignalOnly

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SigId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Number

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Category

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompactFormatter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Map<String, Value>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for Schur<N, D> where
    D: Debug + Dim,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, D, D>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U108

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U56

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U86

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U119

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U61

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U14

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U57

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M4x2<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U30

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U5

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U59

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U84

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U96

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U105

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U103

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M5x2<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U115

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M3x6<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M3x3<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U126

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U77

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TGeneral

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U111

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U38

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U47

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for XY<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U11

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U89

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U43

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for IJKW<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M4x5<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U49

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U36

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U116

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U67

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U66

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U18

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U81

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U74

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U118

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M2x6<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U94

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M6x4<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U65

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for PermutationSequence<D> where
    D: Debug + Dim,
    DefaultAllocator: Allocator<(usize, usize), D, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M6x3<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U83

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U114

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U120

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U52

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U69

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for Quaternion<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U45

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M2x5<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U107

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M5x6<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M3x4<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U41

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U22

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U8

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U70

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for XYZ<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U28

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for XYZWA<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U85

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U16

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D, R> Debug for Similarity<N, D, R> where
    D: Debug + DimName,
    R: Debug,
    N: Debug + Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U91

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U44

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for GivensRotation<N> where
    N: Debug + ComplexField,
    <N as ComplexField>::RealField: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U29

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U92

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U101

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C> Debug for ArrayStorage<N, R, C> where
    C: DimName,
    R: DimName,
    N: Debug,
    <R as DimName>::Value: Mul<<C as DimName>::Value>,
    <<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U127

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U100

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for Orthographic3<N> where
    N: RealField, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U72

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M4x3<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TAffine

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U42

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M4x4<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U12

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U13

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U87

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U7

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U123

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for Perspective3<N> where
    N: RealField, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U95

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C> Debug for LU<N, R, C> where
    C: Debug + Dim,
    R: Debug + DimMin<C>,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, R, C>,
    DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for Point<N, D> where
    D: Debug + DimName,
    N: Debug + Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U2

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U93

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M2x4<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U117

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U113

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U62

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, N, R, C, RStride, CStride> Debug for SliceStorage<'a, N, R, C, RStride, CStride> where
    C: Debug + Dim,
    R: Debug + Dim,
    N: Debug + Scalar,
    RStride: Debug + Dim,
    CStride: Debug + Dim, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U9

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U97

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U112

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U37

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U60

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for DualQuaternion<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U39

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M3x2<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U1

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U55

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U76

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M5x4<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C> Debug for VecStorage<N, R, C> where
    C: Debug + Dim,
    R: Debug + Dim,
    N: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U125

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U73

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D, C> Debug for Transform<N, D, C> where
    C: Debug + TCategory,
    D: Debug + DimNameAdd<U1>,
    N: Debug + RealField,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U106

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U34

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U75

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M2x2<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U21

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U104

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U58

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U51

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for Rotation<N, D> where
    D: Debug + DimName,
    N: Debug + Scalar,
    DefaultAllocator: Allocator<N, D, D>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D, R> Debug for Isometry<N, D, R> where
    D: Debug + DimName,
    R: Debug,
    N: Debug + Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U25

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U40

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for X<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U20

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U46

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for Cholesky<N, D> where
    D: Debug + Dim,
    N: Debug + SimdComplexField,
    DefaultAllocator: Allocator<N, D, D>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U17

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U68

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U15

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U122

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M2x3<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U90

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M5x3<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U80

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U4

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Unit<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C> Debug for FullPivLU<N, R, C> where
    C: Debug + Dim,
    R: Debug + DimMin<C>,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, R, C>,
    DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for XYZWAB<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TProjective

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for SymmetricTridiagonal<N, D> where
    D: Debug + DimSub<U1>,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U10

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for Hessenberg<N, D> where
    D: Debug + DimSub<U1>,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U99

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C> Debug for SVD<N, R, C> where
    C: Debug + Dim,
    R: Debug + DimMin<C>,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, C>,
    DefaultAllocator: Allocator<N, R, <R as DimMin<C>>::Output>,
    DefaultAllocator: Allocator<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1>,
    <N as ComplexField>::RealField: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C> Debug for QR<N, R, C> where
    C: Debug + Dim,
    R: Debug + DimMin<C>,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, R, C>,
    DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C, S> Debug for Matrix<N, R, C, S> where
    C: Dim,
    S: Debug,
    R: Dim,
    N: Scalar, 

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U71

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U26

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C> Debug for Bidiagonal<N, R, C> where
    C: Debug + Dim,
    R: Debug + DimMin<C>,
    N: Debug + ComplexField,
    <R as DimMin<C>>::Output: DimSub<U1>,
    DefaultAllocator: Allocator<N, R, C>,
    DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>,
    DefaultAllocator: Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M5x5<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for SymmetricEigen<N, D> where
    D: Debug + Dim,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<<N as ComplexField>::RealField, D, U1>,
    <N as ComplexField>::RealField: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for UDU<N, D> where
    D: Debug + Dim,
    N: Debug + RealField,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, D>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U50

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M6x6<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, D> Debug for Translation<N, D> where
    D: Debug + DimName,
    N: Debug + Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U27

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U82

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, R, C> Debug for ColPivQR<N, R, C> where
    C: Debug + Dim,
    R: Debug + DimMin<C>,
    N: Debug + ComplexField,
    DefaultAllocator: Allocator<N, R, C>,
    DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>,
    DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U48

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M6x5<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Dynamic

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M3x5<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U79

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U63

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U88

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for XYZW<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U33

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U109

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U23

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U31

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U124

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U78

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M4x6<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U24

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U0

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U53

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for M6x2<N> where
    N: Debug + Scalar, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, N, R, C, RStride, CStride> Debug for SliceStorageMut<'a, N, R, C, RStride, CStride> where
    C: Debug + Dim,
    R: Debug + Dim,
    N: Debug + Scalar,
    RStride: Debug + Dim,
    CStride: Debug + Dim, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U102

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U110

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U3

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U54

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U6

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U98

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U121

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U35

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U19

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for AutoBoolSimd<N> where
    N: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N> Debug for AutoSimd<N> where
    N: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for ParseComplexError<E> where
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Complex<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, N> Debug for GenericArrayIter<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, N> Debug for GenericArray<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<V, A> Debug for TArr<V, A> where
    A: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Equal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Z0

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U, B> Debug for UInt<U, B> where
    B: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Greater

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for B1

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ATerm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Less

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U> Debug for PInt<U> where
    U: Debug + Unsigned + NonZero, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for B0

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UTerm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U> Debug for NInt<U> where
    U: Debug + Unsigned + NonZero, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for InBuffer<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CParameter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FrameFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for OutBuffer<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_parameters

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_CCtx_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_dictContentType_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_outBuffer_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_frameType_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZDICT_fastCover_params_t

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_customMem

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_strategy

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_dictLoadMethod_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_inBuffer_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_DDict_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_literalCompressionMode_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_forceIgnoreChecksum_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_ResetDirective

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_sequenceFormat_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_DCtx_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_Sequence

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_CDict_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_format_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_compressionParameters

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZDICT_legacy_params_t

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_refMultipleDDicts_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTDMT_CCtx_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_frameProgression

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_EndDirective

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_bounds

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_frameParameters

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_dictAttachPref_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_CCtx_params_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_nextInputType_e

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for __locale_struct

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_dParameter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_frameHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZDICT_cover_params_t

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for __locale_data

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZSTD_cParameter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ZDICT_params_t

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for POOL_ctx_s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LoadError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Mesh

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Material

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Model

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Backtrace

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BacktraceSymbol

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SymbolName<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for BytesOrWideString<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Symbol

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Frame

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BacktraceFrame

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryDemangleError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Demangle<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Attribute<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLang

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwVirtuality

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Offset> Debug for UnitType<Offset> where
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugAbbrevOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LocListIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugLineStr<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for CallFrameInstructionIter<'a, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwAt

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugRngListsBase<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugStrOffsetsIndex<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugRngListsIndex<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for EhFrame<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwRle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LineRow

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DieReference<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for Piece<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Abbreviation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugStrOffsetsBase<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PubTypesEntryIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwCfa

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for CfaRule<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PubNamesEntryIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugMacroOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RawRngListIter<R> where
    R: Debug + Reader, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RawLocListEntry<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugFrameOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwInl

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwCc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for IncompleteLineProgram<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Augmentation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugLocListsBase<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ColumnType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Arm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugLocListsIndex<T> where
    T: Debug, 

pub 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>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwMacro

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RangeLists<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReaderOffsetId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugPubNames<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for CompleteLineProgram<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValueType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RangeListsOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugTypes<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RangeIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, R> Debug for EntriesCursor<'abbrev, 'unit, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for CommonInformationEntry<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for UnwindTable<'a, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugLineStrOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwVis

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for FileEntry<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwChildren

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwIdx

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for Operation<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, R> Debug for EntriesTree<'abbrev, 'unit, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugInfoUnitHeadersIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnitOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LocationLists<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, R, Offset> Debug for DebuggingInformationEntry<'abbrev, 'unit, R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLns

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugInfoOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwUt

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ParsedEhFrameHdr<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, 'tree, R> Debug for EntriesTreeIter<'abbrev, 'unit, 'tree, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugStrOffsets<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugLineOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for EhHdrTable<'a, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwoId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for FrameDescriptionEntry<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwAddr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pointer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for EhFrameOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLnct

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for UnwindTableRow<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'iter, R> Debug for RegisterRuleIter<'iter, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugAddr<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugMacinfoOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwAte

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'input, Endian> Debug for EndianSlice<'input, Endian> where
    Endian: Debug + Endianity, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Register

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Format

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, 'tree, R> Debug for EntriesTreeNode<'abbrev, 'unit, 'tree, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for OperationIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwForm

pub 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>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionBaseAddresses

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RunTimeEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Expression<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwDs

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, R> Debug for EntriesRaw<'abbrev, 'unit, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for X86_64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for LineProgramHeader<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Evaluation<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'entry, 'unit, R> Debug for AttrsIter<'abbrev, 'entry, 'unit, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RngListIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwEnd

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BaseAddresses

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwAccess

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LocationListsOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RawRngListEntry<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RegisterRule<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for UninitializedUnwindContext<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ArangeEntry<T> where
    T: Debug + Copy, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LineSequence<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugAbbrev<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugRngLists<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugTypesOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DebugTypeSignature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwDsc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for UnitHeader<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Program, Offset> Debug for LineRows<R, Program, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset,
    Program: Debug + LineProgram<R, Offset>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LocationListEntry<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for EvaluationResult<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LittleEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for UnwindContext<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AttributeSpecification

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RawLocListIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugStrOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwEhPe

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugAddrBase<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LineEncoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugFrame<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for Unit<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PubTypesEntry<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LineInstructions<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLne

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugRanges<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for LineInstruction<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ArangeEntryIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for AttributeValue<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwOp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwDefaulted

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugLocLists<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnitSectionOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Range

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugAddrIndex<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugPubTypes<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwarfFileType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for Location<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwTag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugStr<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileEntryFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugLoc<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugLine<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PubNamesEntry<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Abbreviations

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for CallFrameInstruction<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugAranges<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for EhFrameHdr<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugInfo<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Encoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwOrd

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Dwarf<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for X86

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugTypesUnitHeadersIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for NoteHeader32<E> where
    E: Debug + Endian, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageRomOptionalHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FatArch32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for Import<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSymbol

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for VersionMinCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for PreboundDylibCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SectionHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Relocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for ArchiveFile<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for ObjectMap<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfComdatSectionIterator<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SymbolMap<T> where
    T: Debug + SymbolMapEntry, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibReference<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnonObjectHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SymbolSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Rela32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Sym64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SubUmbrellaCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageBoundImportDescriptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibTableOfContents<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U16Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocation32V2

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageTlsDirectory32

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSymbol<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug,
    <Elf as FileHeader>::Sym: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for DynamicRelocationIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for NoteIterator<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSection<'data, 'file, Mach> where
    'data: 'file,
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Header

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeSection<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSymbolIterator<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Syminfo32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeComdat<'data, 'file, Pe> where
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for IdentCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageArm64RuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for LcStr<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageHotPatchHashes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SubLibraryCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageOptionalHeader32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for SectionRelocationIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageNtHeaders32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Rel32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeSegment<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Mach> Debug for MachOFile<'data, Mach> where
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocation64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfComdatIterator<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Section> Debug for SymbolFlags<Section> where
    Section: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for SymbolIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationSections

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageCor20Header

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FatArch64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Pe> Debug for PeFile<'data, Pe> where
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for SymbolTable<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I32Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageFileHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDirectoryString

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSymbolTable<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for Segment<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Fvmlib<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Section32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSymbolExBytes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for RoutinesCommand_64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Syminfo64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeSectionIterator<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSectionIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for LinkerOptionCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageTlsDirectory64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageCoffSymbolsHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOComdat<'data, 'file, Mach> where
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SubClientCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImportObjectHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOComdatIterator<'data, 'file, Mach> where
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnonObjectHeaderBigobj

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for Section<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylinkerCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageArchitectureEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FileHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SegmentCommand64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDosHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for SegmentIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for EntryPointCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for Note<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::NoteHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageLoadConfigCodeIntegrity

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Sym32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageFunctionEntry64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageEnclaveConfig64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LittleEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for File<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DysymtabCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageRomHeaders

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DataInCodeEntry<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSymbolIterator<'data, 'file, Elf> where
    Elf: FileHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeComdatIterator<'data, 'file, Pe> where
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressionFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for EncryptionInfoCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for ThreadCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Nlist32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfComdat<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug,
    <Elf as FileHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSymbolIterator<'data, 'file, Mach> where
    Mach: MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for ArchiveMember<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolTokenDef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSectionIterator<'data, 'file, Mach> where
    Mach: MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolFunction

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SymtabCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocation64V2

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionIndex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageLoadConfigDirectory64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSymbolTable<'data, 'file, Mach> where
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for CoffFile<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for Bytes<'data>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSegment<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibModule32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageExportDirectory

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for ObjectMapEntry<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SectionHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Dyn64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Dylib<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I64Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for Export<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSectionHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImagePrologueDynamicRelocationHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageHotPatchInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ComdatKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for Symbol<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDebugDirectory

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageEpilogueDynamicRelocationHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FvmfileCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for MachHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDirectoryEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for TwolevelHint<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for RpathCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for LinkeditDataCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for SymbolTable<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeSegmentIterator<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDataDirectory

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageImportDescriptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Guid

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDelayloadDescriptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for SymbolMapName<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSymbolBytes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ScatteredRelocationInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for NoteCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for CompressedData<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSymbolTable<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageBoundForwarderRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for SymbolTable<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Sym: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SymbolIndex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Architecture

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for ComdatIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for RoutinesCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageOs2Header

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SymbolScope

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationTarget

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for Comdat<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Nlist64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for ComdatSectionIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageRelocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDataEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffComdatSectionIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for PeRelocationIterator<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SegmentCommand32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NoDynamicRelocationIterator

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageArmRuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FvmlibCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSection<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for ProgramHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationEncoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BinaryFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfDynamicRelocationIterator<'data, 'file, Elf> where
    Elf: FileHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageLoadConfigDirectory32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Rela64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageArchiveMemberHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for CompressionHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for ProgramHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NonPagedDebugInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAlpha64RuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SymbolKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for SectionTable<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDirStringU

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocation32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for SectionIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageFunctionEntry

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSymbol<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for ArchiveMemberIterator<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageVxdHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSectionRelocationIterator<'data, 'file, Elf> where
    Elf: FileHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for LoadCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageBaseRelocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Mach> Debug for SymbolTable<'data, Mach> where
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Nlist: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOSymbol<'data, 'file, Mach> where
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Nlist: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I16Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for BuildVersionCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDirectory

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageImportByName

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for CompressionHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SourceVersionCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageOptionalHeader64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ident

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AddressSize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for MachHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe> Debug for PeComdatSectionIterator<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSeparateDebugHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageHotPatchBase

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Dyn32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Endianness

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Relocation<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for SectionTable<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for EncryptionInfoCommand64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachORelocationIterator<'data, 'file, Mach> where
    Mach: MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnonObjectHeaderV2

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageLinenumber

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageRuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSegmentIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageEnclaveImport

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for NoteHeader64<E> where
    E: Debug + Endian, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ArchiveKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolFunctionBeginEnd

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageNtHeaders64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FatHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocationTable

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U64Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffComdat<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U32Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UuidCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Rel64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolCrc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDebugMisc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for StringTable<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageEnclaveConfig32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SubFrameworkCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FileHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolWeak

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAlphaRuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffRelocationIterator<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for BuildToolVersion<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SymSegCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibModule64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for TwolevelHintsCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach> Debug for MachOComdatSectionIterator<'data, 'file, Mach> where
    'data: 'file,
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for ElfFile<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug,
    <Elf as FileHeader>::ProgramHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffComdatIterator<'data, 'file> where
    'data: 'file, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Section64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DyldInfoCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSymbolEx

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for PrebindCksumCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TDEFLStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MZFlush

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MZStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DataFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressionLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressionStrategy

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MZError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StreamResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TINFLStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TDEFLFlush

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Adler32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Loading content...

Implementors

impl Debug for Button

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for grafix_toolbox::events::Event

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for EventReply

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for grafix_toolbox::events::Key

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Async::sync::atomic::Ordering

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::FS::Archive::Resource

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for grafix_toolbox::uses::FS::File::Resource

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for grafix_toolbox::uses::FS::Text::Resource

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for RecvTimeoutError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Sync::chan::chan::TryRecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::cmp::Ordering

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Alignment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::io::ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SeekFrom

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for f16

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Mod

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for grafix_toolbox::uses::Async::io::Empty

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Async::io::Repeat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Async::io::Sink

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicBool

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicI8

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicI16

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicI32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicI64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicIsize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicU8

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicU16

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicU32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicU64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicUsize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Async::sync::Barrier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Async::sync::BarrierWaitResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Async::sync::Once

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Semaphore

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SemaphoreGuardArc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GL_TEXTURE_1D

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_1D_ARRAY

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_2D

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_2D_ARRAY

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_2D_MULTISAMPLE

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_2D_MULTISAMPLE_ARRAY

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_3D

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_BUFFER

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_CUBE_MAP

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for GL_TEXTURE_CUBE_MAP_ARRAY

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for RED

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for RG

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for RGB

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for RGBA

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for TexParam

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for grafix_toolbox::uses::Sync::chan::chan::RecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Sync::sync::Barrier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::Sync::sync::BarrierWaitResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Condvar

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnceState

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WaitTimeoutResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::fmt::Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SipHasher

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::io::Empty

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::io::Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Initializer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::io::Repeat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::io::Sink

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stderr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stdin

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stdout

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RangeFull

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PathBuf

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StripPrefixError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for XorShiftRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IgnoredAny

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for grafix_toolbox::uses::serde_impl::de::value::Error

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CachedStr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Path

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Duration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Instant

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SystemTime

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SystemTimeError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Arguments<'_>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for StderrLock<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for StdinLock<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for StdoutLock<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Components<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Display<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for grafix_toolbox::uses::path::Iter<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, B> Debug for Cow<'_, B> where
    B: Debug + ToOwned + ?Sized,
    <B as ToOwned>::Owned: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for grafix_toolbox::uses::Async::sync::MutexGuard<'_, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for grafix_toolbox::uses::Async::sync::RwLockReadGuard<'_, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for RwLockUpgradableReadGuard<'_, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for grafix_toolbox::uses::Async::sync::RwLockWriteGuard<'_, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for grafix_toolbox::uses::Sync::sync::MutexGuard<'_, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for grafix_toolbox::uses::Sync::sync::RwLockReadGuard<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for grafix_toolbox::uses::Sync::sync::RwLockWriteGuard<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for grafix_toolbox::uses::slice::Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for grafix_toolbox::uses::slice::IterMut<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, P> Debug for grafix_toolbox::uses::slice::RSplit<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, P> Debug for RSplitMut<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, P> Debug for grafix_toolbox::uses::slice::RSplitN<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, P> Debug for RSplitNMut<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, P> Debug for grafix_toolbox::uses::slice::Split<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, P> Debug for SplitMut<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, P> Debug for grafix_toolbox::uses::slice::SplitN<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, P> Debug for SplitNMut<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Component<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Prefix<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SemaphoreGuard<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for IoSlice<'a>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for IoSliceMut<'a>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Ancestors<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PrefixComponent<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for BytesDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for FillBuf<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadExactFuture<'a, R> where
    R: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadFuture<'a, R> where
    R: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadLineFuture<'a, R> where
    R: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadToEndFuture<'a, R> where
    R: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadToStringFuture<'a, R> where
    R: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadUntilFuture<'a, R> where
    R: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadVectoredFuture<'a, R> where
    R: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for SeekFuture<'a, S> where
    S: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for grafix_toolbox::uses::Sync::chan::chan::Iter<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for TryIter<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Chunks<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ChunksExact<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ChunksExactMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ChunksMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RChunks<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RChunksExact<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RChunksExactMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RChunksMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Windows<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, P> Debug for GroupBy<'a, T, P> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, P> Debug for GroupByMut<'a, T, P> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, const N: usize> Debug for ArrayChunks<'a, T, N> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, const N: usize> Debug for ArrayChunksMut<'a, T, N> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, const N: usize> Debug for ArrayWindows<'a, T, N> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for CloseFuture<'a, W> where
    W: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for FlushFuture<'a, W> where
    W: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for WriteAllFuture<'a, W> where
    W: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for WriteFuture<'a, W> where
    W: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for WriteVectoredFuture<'a, W> where
    W: Debug + Unpin + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E>

pub fn fmt(&self, formatter: &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, 

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for grafix_toolbox::uses::iter::Repeat<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for grafix_toolbox::uses::iter::Chain<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for grafix_toolbox::uses::iter::Zip<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for grafix_toolbox::uses::io::Lines<B> where
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for grafix_toolbox::uses::io::Split<B> where
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B, C> Debug for ControlFlow<B, C> where
    C: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Dyn> Debug for DynMetadata<Dyn> where
    Dyn: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I128Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U128Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for FromFn<F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for OnceWith<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for grafix_toolbox::uses::iter::RepeatWith<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<H> Debug for BuildHasherDefault<H>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for grafix_toolbox::uses::iter::Cloned<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for grafix_toolbox::uses::iter::Copied<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for grafix_toolbox::uses::iter::Cycle<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for grafix_toolbox::uses::iter::Enumerate<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for grafix_toolbox::uses::iter::Fuse<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Intersperse<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Clone,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Peekable<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for grafix_toolbox::uses::iter::Skip<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for grafix_toolbox::uses::iter::StepBy<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for grafix_toolbox::uses::iter::Take<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    I: Debug, 

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for grafix_toolbox::uses::iter::FilterMap<I, F> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for grafix_toolbox::uses::iter::Inspect<I, F> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for grafix_toolbox::uses::iter::Map<I, F> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, G> Debug for IntersperseWith<I, G> where
    G: Debug,
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, P> Debug for grafix_toolbox::uses::iter::Filter<I, P> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, P> Debug for MapWhile<I, P> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, P> Debug for grafix_toolbox::uses::iter::SkipWhile<I, P> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, P> Debug for grafix_toolbox::uses::iter::TakeWhile<I, P> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, St, F> Debug for grafix_toolbox::uses::iter::Scan<I, St, F> where
    I: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, U> Debug for grafix_toolbox::uses::iter::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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, U, F> Debug for grafix_toolbox::uses::iter::FlatMap<I, U, F> where
    I: Debug,
    U: IntoIterator,
    <U as IntoIterator>::IntoIter: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for grafix_toolbox::uses::ops::Range<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for RangeFrom<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for RangeInclusive<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for RangeTo<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for RangeToInclusive<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for BTreeMap<K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S, A> Debug for grafix_toolbox::uses::HashMap<K, V, S, A> where
    A: Allocator + Clone,
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R1, R2> Debug for grafix_toolbox::uses::Async::io::Chain<R1, R2> where
    R1: Debug,
    R2: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for grafix_toolbox::uses::Async::io::BufReader<R> where
    R: AsyncRead + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for grafix_toolbox::uses::Async::io::Bytes<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for grafix_toolbox::uses::Async::io::Lines<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for grafix_toolbox::uses::Async::io::Split<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for grafix_toolbox::uses::Async::io::Take<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for grafix_toolbox::uses::io::BufReader<R> where
    R: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for grafix_toolbox::uses::io::Bytes<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S: Debug + TexSize, F: Debug + TexFmt> Debug for VTex2d<S, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<S: Debug + TexSize, F: Debug + TexFmt> Debug for Image<S, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<T> Debug for grafix_toolbox::uses::Sync::chan::chan::TrySendError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TryLockError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Bound<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Async::chan::Receiver<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Async::chan::Sender<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for AssertAsync<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Async::io::BlockOn<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Async::io::Cursor<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Unblock<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for AtomicPtr<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Async::sync::Mutex<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for MutexGuardArc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Async::sync::RwLock<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Task<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Sync::chan::chan::IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Sync::chan::chan::Receiver<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Sync::chan::chan::SendError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Sync::chan::chan::Sender<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SyncSender<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Sync::sync::Mutex<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PoisonError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Sync::sync::RwLock<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Sync::sync::Weak<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Reverse<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::io::Cursor<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::io::Take<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::iter::Empty<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::iter::Once<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Rev<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Discriminant<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ManuallyDrop<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for NonNull<T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for BTreeSet<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Cell<T> where
    T: Copy + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PhantomData<T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Rc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnsafeCell<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for VecDeque<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for grafix_toolbox::uses::Weak<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for MaybeUninit<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F> Debug for Successors<T, F> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S, A> Debug for grafix_toolbox::uses::HashSet<T, S, A> where
    S: BuildHasher,
    T: Eq + Hash + Debug,
    A: Allocator + Clone, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for grafix_toolbox::uses::io::Chain<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T: Debug + State> Debug for Object<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<T: Debug + TexType, S: Debug + TexSize, F: Debug + TexFmt> Debug for Tex<T, S, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<T: Debug> Debug for Texture<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<W> Debug for grafix_toolbox::uses::Async::io::BufWriter<W> where
    W: AsyncWrite + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for grafix_toolbox::uses::io::BufWriter<W> where
    W: Write + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for IntoInnerError<W> where
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for LineWriter<W> where
    W: Write + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for Uniform<X> where
    X: Debug + SampleUniform,
    <X as SampleUniform>::Sampler: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Y, R> Debug for GeneratorState<Y, R> where
    R: Debug,
    Y: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Loading content...