Trait rustsec::package::checksum::fmt::Debug

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

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Stability

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

Examples

Deriving an implementation:

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

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

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

Manually implementing:

use std::fmt;

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

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

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

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

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

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

Pretty-printing with #?:

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

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

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

Required methods

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

Formats the value using the given formatter.

Examples

use std::fmt;

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

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

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

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

Loading content...

Implementations on Foreign Types

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

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

impl Debug for WaitTimeoutResult

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 Debug for Repeat

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<T> Debug for Key<T>

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<T> Debug for SyncOnceCell<T> where
    T: Debug, 

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

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

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 ThreadId

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 Debug for UdpSocket

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<'_, 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 DirEntry

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

impl Debug for Shutdown

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

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

impl Debug for StripPrefixError

pub fn fmt(&self, f: &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<'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<'_, K, V> Debug for OccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

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

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

impl Debug for ChildStdin

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

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

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 Metadata

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 StdinLock<'_>

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

impl Debug for Stderr

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 FileType

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 Debug for RecvError

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

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

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

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

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

impl Debug for SystemTime

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

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

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

impl Debug for FromVecWithNulError

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 Display<'_>

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, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

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

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

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 SocketAddr

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

impl Debug for Stdio

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

impl Debug for VarsOs

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

impl Debug for DirBuilder

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<R> Debug for Bytes<R> where
    R: Debug, 

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 Values<'_, K, V> where
    V: Debug, 

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

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

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

impl Debug for UnixStream

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

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

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 ExitCode

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 SeekFrom

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

impl Debug for ArgsOs

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

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

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 UnixDatagram

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

impl<'a> Debug for IoSlice<'a>

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

impl<T> Debug for PoisonError<T>

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<T> Debug for SyncSender<T>

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 Output

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

impl Debug for Path

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

impl Debug for TryRecvError

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<'_, K> Debug for Drain<'_, K> where
    K: Debug, 

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 SocketAddrV4

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

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

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

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

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

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

impl Debug for Sink

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 Stdout

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

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

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 AccessError

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

impl Debug for FromBytesWithNulError

pub fn fmt(&self, f: &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 Debug for File

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 IpAddr

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

impl Debug for Barrier

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

impl Debug for Vars

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

impl Debug for Args

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

impl<T> Debug for Sender<T>

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

impl Debug for Ipv6Addr

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<T> Debug for IntoIter<T> where
    T: Debug, 

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

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

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

impl Debug for OsString

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

impl Debug for ExitStatus

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

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

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

impl Debug for Permissions

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 Debug for ReadDir

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

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

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

impl Debug for UCred

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

impl Debug for RandomState

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 SystemTimeError

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

impl Debug for Empty

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

impl Debug for RecvTimeoutError

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

impl Debug for SocketAddrV6

pub fn fmt(&self, fmt: &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<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> where
    K: Debug,
    V: 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 Debug for Thread

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 Iter<'_>

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 Debug for Builder

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

impl Debug for UnixListener

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

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

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 SplitPaths<'_>

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

impl Debug for OnceState

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

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

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 BacktraceStatus

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

impl Debug for TcpListener

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 Instant

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

impl Debug for CStr

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

impl<T> Debug for Receiver<T>

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 Ipv4Addr

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

impl Debug for DefaultHasher

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 VarError

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

impl Debug for OsStr

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

impl<T> Debug for Cursor<T> where
    T: 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 BarrierWaitResult

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<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

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

impl Debug for System

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

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

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

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

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

impl Debug for Ipv6MulticastScope

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

impl Debug for CString

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

impl<B> Debug for Split<B> where
    B: 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 Components<'_>

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 Once

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 AddrParseError

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<T> Debug for TrySendError<T>

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, 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 Debug for AtomicU64

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<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<Idx> Debug for Range<Idx> where
    Idx: Debug, 

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

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

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

impl Debug for AtomicI64

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<I, F> Debug for Map<I, F> where
    I: Debug, 

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 EscapeDefault

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 unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

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<T6, T7, T8, T9, T10, T11> Debug for (T6, T7, T8, T9, T10, T11) where
    T10: Debug,
    T11: Debug + ?Sized,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug, 

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 Debug for IntErrorKind

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

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

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

impl Debug for Utf8Lossy

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<T> Debug for ManuallyDrop<T> where
    T: Debug + ?Sized, 

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

impl Debug for NonZeroI64

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

impl Debug for RawWakerVTable

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

impl Debug for Utf8Error

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<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 __m256

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

impl Debug for __m512i

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 ()

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

impl Debug for __m512d

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<T> Debug for Pending<T>

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

impl<T> Debug for Empty<T>

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, D, E, F> Debug for fn(A, B, C, D, E, F) -> 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 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 __m128d

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

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

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

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<T> Debug for Reverse<T> where
    T: 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 Debug for ParseBoolError

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

impl<T, E> Debug for Result<T, E> where
    E: Debug,
    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<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> Debug for unsafe extern "C" fn(A, B, ...) -> Ret

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<T> Debug for UnsafeCell<T> where
    T: 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> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G) -> 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 Debug for NonZeroU8

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<Ret, A, B, C> Debug for fn(A, B, C) -> Ret

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

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

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

impl Debug for AtomicBool

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 Debug for EscapeDefault

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

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

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

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

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<T> Debug for Wrapping<T> where
    T: Debug, 

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<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

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

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

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 Debug for char

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

impl Debug for NonZeroI16

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<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<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<Ret> Debug for fn() -> Ret

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

impl Debug for ParseCharError

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> Debug for extern "C" fn(A, B, C, ...) -> Ret

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

impl Debug for AtomicU8

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 Debug for NonZeroI8

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 Debug for AtomicI16

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

impl Debug for NonZeroU32

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

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, 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<F> Debug for FromFn<F>

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

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

impl Debug for SipHasher

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

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

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<'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 Debug for u128

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<'a, A> Debug for Iter<'a, A> where
    A: 'a + Debug, 

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

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

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

impl<C, B> Debug for ControlFlow<C, B> where
    B: Debug,
    C: Debug, 

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 isize

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

impl Debug for AtomicU16

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>

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, 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<I, F> Debug for FilterMap<I, F> where
    I: Debug, 

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<T> Debug for OnceCell<T> where
    T: 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<I, P> Debug for SkipWhile<I, P> where
    I: Debug, 

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

impl Debug for __m256d

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

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

impl Debug for __m128

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

impl Debug for Ordering

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 IterMut<'_, T> where
    T: Debug, 

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

impl<I> Debug for Enumerate<I> where
    I: 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 Debug for EscapeUnicode

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 Debug for Ordering

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<'_, T> Debug for RefMut<'_, T> where
    T: Debug + ?Sized, 

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

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

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 NonZeroU64

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

impl Debug for NonZeroU16

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<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 f32

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

impl Debug for TypeId

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

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<T7, T8, T9, T10, T11> Debug for (T7, T8, T9, T10, T11) where
    T10: Debug,
    T11: Debug + ?Sized,
    T7: Debug,
    T8: Debug,
    T9: Debug, 

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<Ret, A, B, C, D> Debug for unsafe fn(A, B, C, D) -> Ret

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<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<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<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<I, St, F> Debug for Scan<I, St, F> where
    I: Debug,
    St: Debug, 

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

impl Debug for __m512

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<Ret, A> Debug for unsafe extern "C" fn(A) -> Ret

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

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

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

impl Debug for bool

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 Debug for usize

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

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<'a, T> Debug for RChunksMut<'a, T> where
    T: 'a + Debug, 

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

impl Debug for CpuidResult

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

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, 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<'_, T, P> Debug for SplitMut<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: Debug, 

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

impl Debug for BorrowError

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

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

impl Debug for ParseFloatError

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<'a, T> Debug for ChunksExact<'a, T> where
    T: 'a + Debug, 

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, B> Debug for fn(A, B) -> Ret

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<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<'_, T, P> Debug for SplitInclusive<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: 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 Debug for AtomicUsize

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

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

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

impl Debug for ParseIntError

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 AtomicI32

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<I> Debug for Fuse<I> where
    I: Debug, 

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

impl Debug for RangeFull

pub fn fmt(&self, fmt: &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<I> Debug for Peekable<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

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

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

pub fn fmt(&self, fmt: &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<I> Debug for Take<I> where
    I: Debug, 

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 Debug for BorrowMutError

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<'_, T, P> Debug for RSplitMut<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: Debug, 

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, T, const N: usize> Debug for ArrayChunks<'a, T, N> where
    T: 'a + 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 Layout

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<I> Debug for Copied<I> where
    I: Debug, 

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 Debug for NonZeroI128

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<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<Ret, A, B, C, D> Debug for fn(A, B, C, D) -> Ret

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

impl<'_, T, P> Debug for RSplit<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: 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<T, F> Debug for Successors<T, F> 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<A, B> Debug for Chain<A, B> where
    A: Debug,
    B: Debug, 

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

impl Debug for Waker

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

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

pub fn fmt(&self, fmt: &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 !

pub fn fmt(&self, &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<'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<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 Debug for TryFromSliceError

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 Debug for Infallible

pub fn fmt(&self, &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 NonZeroIsize

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

impl Debug for CharTryFromError

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

impl Debug for RawWaker

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

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

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

impl Debug for f64

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

impl Debug for NoneError

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<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<I> Debug for Cloned<I> where
    I: Debug, 

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<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<Idx> Debug for RangeFrom<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &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 Debug for NonZeroI32

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

impl Debug for __m128i

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 SearchStep

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

impl Debug for i128

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<T> Debug for *mut T where
    T: ?Sized, 

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

impl Debug for LayoutErr

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<Idx> Debug for RangeToInclusive<Idx> where
    Idx: Debug, 

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

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

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

impl Debug for __m256i

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 Debug for i8

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<I> Debug for Skip<I> where
    I: Debug, 

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

impl<A, B> Debug for Zip<A, B> where
    A: Debug,
    B: 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<P> Debug for Pin<P> where
    P: Debug, 

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

impl Debug for i32

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

impl Debug for i64

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<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> Debug for unsafe extern "C" fn(A, B) -> Ret

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

impl Debug for EscapeDebug

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

impl Debug for AtomicI8

pub fn fmt(&self, f: &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, 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<'a> Debug for Utf8LossyChunk<'a>

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<I> Debug for StepBy<I> where
    I: Debug, 

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

impl Debug for TryFromIntError

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<T> Debug for AtomicPtr<T>

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 FpCategory

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

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 PhantomPinned

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

impl Debug for ToUppercase

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

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

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

impl Debug for str

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<I, P> Debug for MapWhile<I, P> where
    I: Debug, 

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, 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<'_, T, P> Debug for RSplitNMut<'_, T, P> where
    P: FnMut(&T) -> bool,
    T: Debug, 

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

impl Debug for i16

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, 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<T> Debug for *const T where
    T: ?Sized, 

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

impl Debug for u8

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, 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> Debug for IntoIter<A> where
    A: Debug, 

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 Debug for u64

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 MaybeUninit<T>

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> Debug for unsafe extern "C" fn(A, B, C, D, E, F) -> 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, 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<'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 Debug for AllocError

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<I, F> Debug for Inspect<I, F> where
    I: Debug, 

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

impl Debug for NonZeroUsize

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 Debug for u16

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<I, P> Debug for Filter<I, P> where
    I: Debug, 

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

impl Debug for Duration

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 u32

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<I> Debug for Cycle<I> where
    I: 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<'_, K, V> Debug for RangeMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

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

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

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

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

impl Debug for String

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 TryReserveError

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

impl Debug for FromUtf8Error

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

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

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

impl Debug for FromUtf16Error

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 Keys<'_, K, V> where
    K: Debug, 

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<'_, K, V> Debug for Values<'_, K, V> where
    V: 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<'_, T, F> Debug for DrainFilter<'_, T, F> where
    F: FnMut(&mut T) -> bool,
    T: Debug, 

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 Debug for Global

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 Cursor<'_, 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 BTreeSet<T> where
    T: Debug, 

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

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

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 Box<T> where
    T: Debug + ?Sized, 

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<'_, 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<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

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 Difference<'_, 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,
    K: Debug,
    V: 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 Iter<'_, 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 Iter<'_, T> where
    T: Debug, 

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

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

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

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

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

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

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<'_, T> Debug for Drain<'_, 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<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Ord + Debug, 

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

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

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

impl<T> Debug for Weak<T> where
    T: 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<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: 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<'_, T, F> Debug for DrainFilter<'_, T, F> where
    F: FnMut(&T) -> bool,
    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<'a, T> Debug for Range<'a, T> where
    T: 'a + Debug, 

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

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

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

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

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 Union<'_, 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<T> Debug for IntoIter<T> where
    T: Debug, 

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

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

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

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

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 Debug for _Unwind_Reason_Code

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

impl Debug for PlatformReq

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

impl Debug for Env

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

impl Debug for Arch

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

impl Debug for Tier

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

impl Debug for Platform

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

impl Debug for OS

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

impl Debug for Error

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<E> Debug for F32Deserializer<E> where
    E: Debug, 

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

impl<E> Debug for CharDeserializer<E> where
    E: Debug, 

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

impl<E> Debug for I32Deserializer<E> where
    E: Debug, 

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

impl<E> Debug for U16Deserializer<E> where
    E: Debug, 

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

impl<E> Debug for IsizeDeserializer<E> where
    E: Debug, 

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

impl<E> Debug for I8Deserializer<E> where
    E: Debug, 

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

impl<'a, E> Debug for StrDeserializer<'a, E> where
    E: 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<E> Debug for U128Deserializer<E> where
    E: Debug, 

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

impl<E> Debug for U8Deserializer<E> where
    E: Debug, 

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

impl<E> Debug for I16Deserializer<E> where
    E: Debug, 

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

impl<E> Debug for U32Deserializer<E> where
    E: Debug, 

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

impl<E> Debug for BoolDeserializer<E> where
    E: Debug, 

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

impl<E> Debug for UsizeDeserializer<E> where
    E: Debug, 

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

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> where
    E: Debug, 

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

impl<E> Debug for I128Deserializer<E> where
    E: Debug, 

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

impl<E> Debug for StringDeserializer<E> where
    E: Debug, 

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

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

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

impl<'a, E> Debug for CowStrDeserializer<'a, E> where
    E: Debug, 

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

impl Debug for IgnoredAny

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

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> where
    E: Debug, 

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 UnitDeserializer<E> where
    E: Debug, 

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

impl<E> Debug for I64Deserializer<E> where
    E: 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<E> Debug for U64Deserializer<E> where
    E: Debug, 

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

impl<I, E> Debug for SeqDeserializer<I, E> where
    E: Debug,
    I: Debug, 

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

impl<E> Debug for F64Deserializer<E> where
    E: Debug, 

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 SemVerError

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 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 Debug for Identifier

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 Predicate

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

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

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

impl Debug for Local

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

impl Debug for NaiveDateTime

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

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

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

Example

use chrono::NaiveDate;

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

Leap seconds may also be used.

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

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

impl<Tz> Debug for DateTime<Tz> where
    Tz: TimeZone, 

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

impl Debug for InternalFixed

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

impl Debug for ParseWeekdayError

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

impl Debug for ParseMonthError

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

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

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

impl Debug for ParseError

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

impl Debug for Weekday

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

impl Debug for NaiveTime

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

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

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

Example

use chrono::NaiveTime;

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

Leap seconds may also be used.

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

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

impl<'a> Debug for Item<'a>

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

impl<Tz> Debug for Date<Tz> where
    Tz: TimeZone, 

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

impl Debug for NaiveDate

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

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

Example

use chrono::NaiveDate;

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

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

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

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

impl Debug for FixedOffset

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

impl Debug for Utc

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

impl Debug for SecondsFormat

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

impl Debug for InternalNumeric

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

impl Debug for RoundingError

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

impl Debug for Numeric

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

impl Debug for IsoWeek

The Debug output of the ISO week w is the same as d.format("%G-W%V") where d is any NaiveDate value in that week.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5).iso_week()), "2015-W36");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  3).iso_week()), "0000-W01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31).iso_week()), "9999-W52");

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

assert_eq!(format!("{:?}", NaiveDate::from_ymd(    0,  1,  2).iso_week()),  "-0001-W52");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31).iso_week()), "+10000-W52");

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

impl<'a> Debug for StrftimeItems<'a>

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

impl Debug for Parsed

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

impl Debug for Month

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

impl Debug for Pad

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

impl Debug for Fixed

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

impl Debug for Tm

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

impl Debug for SteadyTime

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

impl<'a> Debug for TmFmt<'a>

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

impl Debug for Duration

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

impl Debug for Timespec

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

impl Debug for ParseError

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

impl Debug for OutOfRangeError

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 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 Scope

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

impl Debug for UserInteraction

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

impl Debug for Score

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

impl Debug for Base

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

impl Debug for Integrity

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

impl Debug for Availability

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

impl Debug for PrivilegesRequired

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

impl Debug for Confidentiality

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

impl Debug for AttackVector

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

impl Debug for AttackComplexity

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 ErrorKind

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 Tree

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

impl Debug for Key

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 Dependency

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 Patch

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

impl<'a, E, Ty, Ix> Debug for EdgeReference<'a, E, Ty, Ix> where
    E: 'a + Debug,
    Ix: 'a + Debug,
    Ty: Debug, 

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

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

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

impl<N, Ix> Debug for Node<N, Ix> where
    Ix: Debug,
    N: Debug, 

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

impl<N, E, Ty, Ix> Debug for StableGraph<N, E, Ty, Ix> where
    E: Debug,
    Ix: IndexType,
    N: Debug,
    Ty: EdgeType, 

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

impl<N, E> Debug for Element<N, E> where
    E: Debug,
    N: Debug, 

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

impl<N, E, Ty, Ix> Debug for Graph<N, E, Ty, Ix> where
    E: Debug,
    Ix: IndexType,
    N: Debug,
    Ty: EdgeType, 

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

impl<'b, T> Debug for Ptr<'b, T> where
    T: Debug, 

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

impl<W, C> Debug for WalkerIter<W, C> where
    C: Debug,
    W: Debug, 

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

impl<E, Ix> Debug for Edge<E, Ix> where
    E: Debug,
    Ix: Debug, 

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

impl<G> Debug for Reversed<G> where
    G: Debug, 

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

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

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

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

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

impl<N, E, Ty, Ix> Debug for Csr<N, E, Ty, Ix> where
    E: Debug,
    Ix: Debug,
    N: Debug,
    Ty: Debug, 

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

impl Debug for Directed

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

impl Debug for EdgesNotSorted

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

impl Debug for Config

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

impl<G, F> Debug for NodeFiltered<G, F> where
    F: Debug,
    G: Debug, 

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

impl Debug for NegativeCycle

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

impl<N, VM> Debug for DfsSpace<N, VM> where
    N: Debug,
    VM: Debug, 

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

impl<N, VM> Debug for Dfs<N, VM> where
    N: Debug,
    VM: Debug, 

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

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

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

impl<Ix> Debug for NodeIndex<Ix> where
    Ix: Debug, 

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

impl<G, F> Debug for EdgeFiltered<G, F> where
    F: Debug,
    G: Debug, 

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

impl<'a, Ix> Debug for Neighbors<'a, Ix> where
    Ix: 'a + Debug, 

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

impl<N, VM> Debug for DfsPostOrder<N, VM> where
    N: Debug,
    VM: Debug, 

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

impl<Ix> Debug for NodeIndices<Ix> where
    Ix: Debug, 

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

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

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

impl<'a, E, Ty, Ix> Debug for Edges<'a, E, Ty, Ix> where
    E: 'a + Debug,
    Ix: 'a + Debug,
    Ty: Debug, 

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

impl<'a, E, Ix> Debug for EdgeReference<'a, E, Ix> where
    E: 'a + Debug,
    Ix: Debug, 

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

impl<Ix> Debug for EdgeIndices<Ix> where
    Ix: Debug, 

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

impl<'a, E, Ix> Debug for EdgeReference<'a, E, Ix> where
    E: 'a + Debug,
    Ix: Debug, 

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

impl Debug for Direction

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

impl<'a, G> Debug for Dot<'a, G> where
    G: IntoEdgeReferences + IntoNodeReferences + NodeIndexable + GraphProp,
    <G as Data>::EdgeWeight: Debug,
    <G as Data>::NodeWeight: Debug, 

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

impl Debug for Undirected

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

impl<N, E, Ty> Debug for GraphMap<N, E, Ty> where
    E: Debug,
    N: Eq + Debug + Hash,
    Ty: EdgeType, 

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

impl<N> Debug for Dominators<N> where
    N: Debug + Copy + Eq + Hash, 

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

impl<Ix> Debug for EdgeIndex<Ix> where
    Ix: Debug, 

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

impl Debug for Time

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

impl Debug for FixedBitSet

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

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

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> Debug for VacantEntry<'_, K, V> where
    K: Debug, 

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

impl<T, S> Debug for IndexSet<T, S> 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<'_, K, V> Debug for Values<'_, K, V> where
    V: 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<'_, K, V> Debug for OccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: 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<'_, K, V> Debug for Entry<'_, K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &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 IndexMap<K, V, S> where
    K: Debug,
    V: Debug, 

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

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

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<'_, K, V, S> Debug for VacantEntry<'_, K, V, S> where
    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<'_, 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 OccupiedEntry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

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

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

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

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

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

impl Debug for TryReserveError

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

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

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

impl<T, S> Debug for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash + 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<'_, K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>

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<'_, K, V, S> Debug for RawOccupiedEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

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

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

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

impl<K> Debug for IntoIter<K> where
    K: 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> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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<'_, K, V, S> Debug for RawEntryBuilder<'_, K, V, S>

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

impl<'_, K, V> Debug for Drain<'_, K, V> where
    K: Debug,
    V: 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, S> Debug for RawVacantEntryMut<'_, K, V, S>

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

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

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

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

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 SyntaxViolation

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

impl<'a> Debug for PathSegmentsMut<'a>

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

impl Debug for OpaqueOrigin

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

impl Debug for Origin

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

impl<'a> Debug for ByteSerialize<'a>

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

impl Debug for Position

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

impl Debug for ParseError

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

impl<'a> Debug for UrlQuery<'a>

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

impl<S> Debug for Host<S> where
    S: Debug, 

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

impl Debug for Url

Debug the serialization of this URL.

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

impl Debug for Errors

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

impl<'text> Debug for InitialInfo<'text>

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

impl Debug for ParagraphInfo

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

impl<'text> Debug for BidiInfo<'text>

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 BidiClass

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

impl Debug for Level

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

impl Debug for IsNormalized

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

impl<A> Debug for ArrayVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

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

impl<A> Debug for TinyVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

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

impl<A> Debug for TinyVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

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

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

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

impl<'a> Debug for PercentDecode<'a>

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

impl Debug for DatetimeParseError

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 Map<String, Value>

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

impl Debug for Value

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

impl Debug for Datetime

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

impl Debug for Error

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

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

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 File

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

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

impl Debug for LocalManifest

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 Error

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

impl Debug for Dependency

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

impl Debug for Manifest

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 ErrorKind

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

impl Debug for Error

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

impl<'a> Debug for Iter<'a>

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

impl<'a, T> Debug for DisplayChain<'a, T> where
    T: 'a + Debug + ?Sized, 

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 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 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 Backtrace

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

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

pub fn fmt(&self, f: &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 LocListIter<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl Debug for DwInl

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

impl<R> Debug for RangeIter<R> where
    R: Reader + Debug, 

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

impl<R> Debug for DebugFrame<R> where
    R: Reader + 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 DwAte

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

impl<R> Debug for EhFrameHdr<R> where
    R: Reader + Debug, 

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<T> Debug for ArangeEntry<T> where
    T: Copy + Debug, 

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

impl<R> Debug for CfaRule<R> where
    R: Reader + Debug, 

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

impl<R> Debug for Expression<R> where
    R: Reader + 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 DebugTypesOffset<T> where
    T: Debug, 

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

impl<R> Debug for ArangeEntryIter<R> where
    R: Reader + Debug, 

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 Debug for X86_64

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 UninitializedUnwindContext<R> where
    R: Reader + Debug, 

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

impl<R, Offset> Debug for Piece<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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 Debug for DwTag

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

impl<R> Debug for DebugPubTypes<R> where
    R: Reader + Debug, 

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

impl<R> Debug for LineSequence<R> where
    R: Reader + Debug, 

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 Debug for DwLnct

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

impl Debug for DwMacro

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

impl Debug for RunTimeEndian

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

impl Debug for BaseAddresses

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 Debug for Pointer

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

impl Debug for DwAddr

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

impl<R> Debug for EvaluationResult<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: 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 IncompleteLineProgram<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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 DwIdx

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 DebugLine<R> where
    R: Debug, 

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

impl<R, Program, Offset> Debug for LineRows<R, Program, Offset> where
    Offset: Debug + ReaderOffset,
    Program: Debug + LineProgram<R, Offset>,
    R: Debug + Reader<Offset = Offset>, 

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 PubNamesEntry<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: 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, Offset> Debug for TypeUnitHeader<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R> Debug for EhFrame<R> where
    R: Reader + 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<T> Debug for DebugAddrIndex<T> where
    T: Debug, 

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

impl Debug for SectionId

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

impl Debug for Augmentation

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

impl Debug for DwCc

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 LineEncoding

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

impl<R> Debug for RawLocListIter<R> where
    R: Reader + Debug, 

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

impl Debug for AttributeSpecification

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

impl Debug for Range

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<R, Offset> Debug for LineInstruction<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for Arm

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

impl<R, Offset> Debug for Location<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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 DwDefaulted

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 TypeUnitHeadersIter<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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<R> Debug for DebugLineStr<R> where
    R: Debug, 

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<T> Debug for DebugLineOffset<T> where
    T: Debug, 

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

impl<R> Debug for CallFrameInstruction<R> where
    R: Reader + 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 DwDsc

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 DwAccess

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

impl Debug for DwOrd

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 ValueType

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

impl Debug for DwCfa

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

impl<'a, R> Debug for EhHdrTable<'a, R> where
    R: Reader + 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 Debug for ColumnType

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 DwLns

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

impl Debug for DwDs

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

impl<R, Offset> Debug for Unit<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for DwRle

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 DebugLineStrOffset<T> where
    T: Debug, 

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 FileEntryFormat

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<R, Offset> Debug for CommonInformationEntry<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<'abbrev, 'unit, R, Offset> Debug for DebuggingInformationEntry<'abbrev, 'unit, R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for LineRow

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

impl<R> Debug for RawRngListIter<R> where
    R: Reader + Debug, 

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

impl<'abbrev, 'unit, 'tree, R> Debug for EntriesTreeIter<'abbrev, 'unit, 'tree, R> where
    R: Reader + Debug, 

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

impl Debug for X86

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

impl<R> Debug for ParsedEhFrameHdr<R> where
    R: Reader + Debug, 

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

impl<R> Debug for DebugAranges<R> where
    R: Reader + Debug, 

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<R> Debug for DebugLocLists<R> where
    R: Debug, 

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

impl Debug for DwForm

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

impl<R> Debug for LocationListEntry<R> where
    R: Reader + Debug, 

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

impl<'a, R> Debug for CallFrameInstructionIter<'a, R> where
    R: Reader + Debug, 

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

impl Debug for Format

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

impl<R, Offset> Debug for Operation<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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 DwId

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

impl Debug for DwAt

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

impl<R> Debug for UnwindContext<R> where
    R: Reader + Debug, 

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

impl<R> Debug for PubTypesEntry<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl Debug for DwEhPe

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

impl Debug for DwEnd

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

impl<R, Offset> Debug for CompleteLineProgram<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for Encoding

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 Evaluation<R> where
    R: Reader + Debug, 

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 DebugPubNames<R> where
    R: Reader + Debug, 

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

impl Debug for DwLang

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 DwVirtuality

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<'a, R> Debug for UnwindTable<'a, R> where
    R: Reader + Debug, 

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

impl Debug for DwLle

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<R> Debug for Dwarf<R> where
    R: Debug, 

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

impl Debug for Value

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

impl<R, Offset> Debug for LineProgramHeader<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R> Debug for LineInstructions<R> where
    R: Reader + Debug, 

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

impl<'abbrev, 'entry, 'unit, R> Debug for AttrsIter<'abbrev, 'entry, 'unit, R> where
    R: Reader + Debug, 

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

impl<R> Debug for Attribute<R> where
    R: Reader + Debug, 

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

impl<R, Offset> Debug for CompilationUnitHeader<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R> Debug for UnwindTableRow<R> where
    R: Reader + Debug, 

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 Debug for DebugTypeSignature

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

impl<R> Debug for RngListIter<R> where
    R: Reader + Debug,
    <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<'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 FrameDescriptionEntry<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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> Debug for OperationIter<R> where
    R: Reader + Debug, 

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 DwOp

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

impl Debug for ReaderOffsetId

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 DebugLoc<R> where
    R: Debug, 

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

impl<R> Debug for RegisterRule<R> where
    R: Reader + Debug, 

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

impl<R, Offset> Debug for UnitHeader<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl<R, Offset> Debug for AttributeValue<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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<'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 RawLocListEntry<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl<R> Debug for PubNamesEntryIter<R> where
    R: Reader + 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<'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<R> Debug for PubTypesEntryIter<R> where
    R: Reader + Debug, 

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 Debug for Abbreviation

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

impl<R> Debug for CompilationUnitHeadersIter<R> where
    R: Reader + Debug,
    <R as Reader>::Offset: Debug, 

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

impl<R, Offset> Debug for FileEntry<R, Offset> where
    Offset: Debug + ReaderOffset,
    R: Debug + Reader<Offset = Offset>, 

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

impl Debug for DwLne

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

impl<'abbrev, 'unit, 'tree, R> Debug for EntriesTreeNode<'abbrev, 'unit, 'tree, R> where
    R: Reader + Debug, 

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

impl<E> Debug for SubLibraryCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for SymtabCommand<E> where
    E: Endian + Debug, 

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

impl<'data, 'file, Mach> Debug for MachOComdatIterator<'data, 'file, Mach> where
    Mach: MachHeader + Debug, 

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

impl<E> Debug for Dylib<E> where
    E: Endian + Debug, 

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

impl<E> Debug for SymSegCommand<E> where
    E: Endian + Debug, 

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

impl<'data, 'file, Mach> Debug for MachOComdatSectionIterator<'data, 'file, Mach> where
    'data: 'file,
    Mach: MachHeader + Debug, 

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

impl<E> Debug for ProgramHeader32<E> where
    E: Endian + Debug, 

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

impl<E> Debug for Rela64<E> where
    E: Endian + Debug, 

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 CoffSegment<'data, 'file> where
    'data: 'file, 

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

impl<'data, Pe> Debug for PeFile<'data, Pe> where
    Pe: ImageNtHeaders + Debug, 

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 ImageDynamicRelocation32V2

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

impl Debug for ImageBaseRelocation

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

impl Debug for ImageArm64RuntimeFunctionEntry

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

impl Debug for ImageResourceDirectory

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

impl<E> Debug for Section32<E> where
    E: Endian + Debug, 

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

impl<'data, 'file, Pe> Debug for PeComdatSectionIterator<'data, 'file, Pe> where
    'data: 'file,
    Pe: ImageNtHeaders + Debug, 

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

impl<E> Debug for DysymtabCommand<E> where
    E: Endian + Debug, 

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 Debug for ImageLoadConfigDirectory32

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

impl<'data, 'file> Debug for RelocationIterator<'data, 'file> where
    'data: 'file, 

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

impl Debug for ImageResourceDirectoryEntry

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<'data> Debug for Bytes<'data>

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

impl<E> Debug for SegmentCommand32<E> where
    E: Endian + Debug, 

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<E> Debug for LinkeditDataCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageOptionalHeader32

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

impl<E> Debug for SectionHeader32<E> where
    E: Endian + Debug, 

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

impl<E> Debug for Section64<E> where
    E: Endian + Debug, 

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

impl Debug for Guid

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

impl<'data, Elf> Debug for ElfNote<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::NoteHeader: Debug, 

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 Rela32<E> where
    E: Endian + Debug, 

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

impl Debug for ImageDelayloadDescriptor

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

impl Debug for AddressSize

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<'data, 'file, Pe> Debug for PeComdatIterator<'data, 'file, Pe> where
    Pe: ImageNtHeaders + Debug, 

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, Pe> Debug for PeSectionIterator<'data, 'file, Pe> where
    'data: 'file,
    Pe: Debug + ImageNtHeaders, 

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

impl Debug for FatHeader

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 Debug for ImageFunctionEntry

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

impl Debug for CompressionFormat

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 ImageSymbolExBytes

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 PreboundDylibCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageCoffSymbolsHeader

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

impl<E> Debug for DyldInfoCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for ThreadCommand<E> where
    E: Endian + Debug, 

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

impl<'data, 'file, Mach> Debug for MachOComdat<'data, 'file, Mach> where
    Mach: MachHeader + Debug, 

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

impl<E> Debug for NoteHeader64<E> where
    E: Endian + Debug, 

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

impl Debug for ImageLoadConfigCodeIntegrity

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<'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 Debug for ImageAlpha64RuntimeFunctionEntry

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 TwolevelHint<E> where
    E: Endian + Debug, 

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 ImageImportDescriptor

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

impl<E> Debug for CompressionHeader32<E> where
    E: Endian + Debug, 

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<Section> Debug for SymbolFlags<Section> where
    Section: Debug, 

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

impl Debug for NonPagedDebugInfo

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

impl<E> Debug for Sym32<E> where
    E: Endian + Debug, 

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<E> Debug for DylibModule32<E> where
    E: Endian + Debug, 

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 RoutinesCommand_64<E> where
    E: Endian + Debug, 

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

impl Debug for RelocationTarget

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

impl<E> Debug for RpathCommand<E> where
    E: Endian + Debug, 

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 NoteHeader32<E> where
    E: Endian + Debug, 

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

impl<E> Debug for FvmfileCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for VersionMinCommand<E> where
    E: Endian + Debug, 

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 RelocationKind

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

impl<E> Debug for Dyn64<E> where
    E: Endian + Debug, 

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 UuidCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageDynamicRelocation64V2

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 BinaryFormat

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 ImageSymbol

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

impl Debug for ImageHotPatchHashes

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

impl Debug for ImagePrologueDynamicRelocationHeader

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

impl<'data, Mach> Debug for MachOFile<'data, Mach> where
    Mach: MachHeader + Debug,
    <Mach as MachHeader>::Endian: Debug, 

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 PeRelocationIterator<'data, 'file>

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> Debug for CoffSection<'data, 'file> where
    'data: 'file, 

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 SectionIndex

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

impl Debug for ImageDebugMisc

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

impl Debug for ImageOptionalHeader64

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

impl<E> Debug for CompressionHeader64<E> where
    E: Endian + Debug, 

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

impl Debug for ImageDebugDirectory

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

impl<E> Debug for PrebindCksumCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for FileHeader64<E> where
    E: Endian + Debug, 

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

impl<E> Debug for TwolevelHintsCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for Dyn32<E> where
    E: Endian + Debug, 

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

impl<E> Debug for MachHeader32<E> where
    E: Endian + Debug, 

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

impl Debug for ImageArchiveMemberHeader

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

impl<'data, Mach> Debug for SymbolTable<'data, Mach> where
    Mach: MachHeader + Debug,
    <Mach as MachHeader>::Nlist: Debug, 

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

impl<E> Debug for DataInCodeEntry<E> where
    E: Endian + 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 ImageResourceDirectoryString

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

impl Debug for ImageDynamicRelocation32

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

impl<E> Debug for Fvmlib<E> where
    E: Endian + Debug, 

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<E> Debug for SubClientCommand<E> where
    E: Endian + Debug, 

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 RelocationSections

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

impl Debug for FatArch32

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

impl<E> Debug for Nlist32<E> where
    E: Endian + Debug, 

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

impl<'data, Elf> Debug for SymbolTable<'data, Elf> where
    Elf: FileHeader + Debug,
    <Elf as FileHeader>::Sym: Debug, 

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 ImageExportDirectory

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> Debug for CoffSymbolIterator<'data, 'file>

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

impl<'data, Elf> Debug for ElfFile<'data, Elf> where
    Elf: FileHeader + Debug,
    <Elf as FileHeader>::Endian: Debug,
    <Elf as FileHeader>::ProgramHeader: Debug, 

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

impl<E> Debug for Syminfo32<E> where
    E: Endian + Debug, 

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

impl Debug for ImageRuntimeFunctionEntry

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

impl<E> Debug for Sym64<E> where
    E: Endian + Debug, 

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 ImageSeparateDebugHeader

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

impl Debug for ImageAuxSymbolWeak

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

impl<E> Debug for DylibModule64<E> where
    E: Endian + Debug, 

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

impl<E> Debug for DylibCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for LoadCommand<E> where
    E: Endian + Debug, 

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<'data> Debug for Symbol<'data>

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 ImageDosHeader

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

impl Debug for SectionKind

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<E> Debug for Syminfo64<E> where
    E: Endian + Debug, 

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 LittleEndian

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, 

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 Rel32<E> where
    E: Endian + Debug, 

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

impl<E> Debug for SectionHeader64<E> where
    E: Endian + Debug, 

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<E> Debug for DylibTableOfContents<E> where
    E: Endian + Debug, 

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 SectionIterator<'data, 'file> where
    'data: 'file, 

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

impl Debug for ImageDataDirectory

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, 

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

impl Debug for SymbolIndex

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

impl<E> Debug for BuildToolVersion<E> where
    E: Endian + Debug, 

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

impl Debug for ImageEpilogueDynamicRelocationHeader

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

impl Debug for ImageNtHeaders64

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

impl<E> Debug for DylibReference<E> where
    E: Endian + Debug, 

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

impl Debug for AnonObjectHeaderBigobj

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 Debug for ImageSectionHeader

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

impl Debug for ImageAuxSymbolFunction

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<E> Debug for NoteCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for FileHeader32<E> where
    E: Endian + Debug, 

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

impl Debug for SymbolKind

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 Nlist64<E> where
    E: Endian + Debug, 

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 ImageArmRuntimeFunctionEntry

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

impl<E> Debug for BuildVersionCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for EncryptionInfoCommand<E> where
    E: Endian + Debug, 

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 ImageEnclaveConfig32

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<E> Debug for EntryPointCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for EncryptionInfoCommand64<E> where
    E: Endian + Debug, 

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 I32Bytes<E> where
    E: Endian, 

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

impl<E> Debug for DylinkerCommand<E> where
    E: Endian + Debug, 

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 Debug for ComdatKind

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

impl Debug for FileFlags

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

impl<'data> Debug for SymbolMap<'data>

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 Debug for SymbolScope

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

impl Debug for ImageArchitectureEntry

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<'data, 'file> Debug for CoffComdatSectionIterator<'data, 'file> where
    'data: 'file, 

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

impl<E> Debug for FvmlibCommand<E> where
    E: Endian + Debug, 

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 Relocation

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 ImageImportByName

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

impl<'data, 'file, Pe> Debug for PeComdat<'data, 'file, Pe> where
    Pe: ImageNtHeaders + Debug, 

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

impl Debug for ImageSymbolBytes

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

impl<E> Debug for SubFrameworkCommand<E> where
    E: Endian + Debug, 

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

impl<E> Debug for ProgramHeader64<E> where
    E: Endian + Debug, 

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

impl Debug for RelocationInfo

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

impl<'data, Elf> Debug for SectionTable<'data, Elf> where
    Elf: FileHeader + Debug,
    <Elf as FileHeader>::SectionHeader: Debug, 

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<E> Debug for RoutinesCommand<E> where
    E: Endian + Debug, 

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 Error

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

impl<E> Debug for LinkerOptionCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageFileHeader

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

impl<E> Debug for SegmentCommand64<E> where
    E: Endian + Debug, 

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 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<'data, 'file> Debug for SymbolIterator<'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<'data> Debug for StringTable<'data>

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 ImageRelocation

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

impl Debug for SymbolSection

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

impl Debug for ImageBoundForwarderRef

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

impl<E> Debug for Rel64<E> where
    E: Endian + Debug, 

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 ImageTlsDirectory32

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

impl<E> Debug for LcStr<E> where
    E: Endian + Debug, 

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 Relocation<E> where
    E: Endian + Debug, 

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

impl<E> Debug for MachHeader64<E> where
    E: Endian + Debug, 

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

impl<'data, 'file, Elf> Debug for ElfRelocationIterator<'data, 'file, Elf> where
    Elf: FileHeader, 

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 ImageAuxSymbolTokenDef

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<E> Debug for SubUmbrellaCommand<E> where
    E: Endian + Debug, 

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

impl Debug for ImageNtHeaders32

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 ImageCor20Header

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 IdentCommand<E> where
    E: Endian + Debug, 

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

impl Debug for Architecture

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

impl<E> Debug for SourceVersionCommand<E> where
    E: 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 Debug for ImageSymbolEx

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

impl Debug for FatArch64

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<'data, Elf> Debug for ElfNoteIterator<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug, 

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

impl Debug for ImageHotPatchBase

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 MZStatus

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 TDEFLStatus

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 StreamResult

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 TDEFLFlush

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 MZFlush

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

impl Debug for Adler32

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 SemVerError

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 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 InlineTable

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

impl Debug for Item

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

impl Debug for Key

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

impl Debug for Document

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

impl Debug for Table

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

impl Debug for ArrayOfTables

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

impl Debug for TomlError

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

impl Debug for Array

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

impl Debug for Value

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

impl<I> Debug for BufferedStream<I> where
    I: Debug + StreamOnce + Positioned,
    <I as StreamOnce>::Item: Debug,
    <I as StreamOnce>::Position: Debug, 

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

impl<I, R, P> Debug for Errors<I, R, P> where
    I: Debug,
    P: Debug,
    R: Debug, 

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

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

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

impl Debug for TakeRange

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

impl<E> Debug for Tracked<E> where
    E: Debug, 

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

impl Debug for SourcePosition

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

impl Debug for PointerOffset

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

impl<T, R> Debug for Error<T, R> where
    R: Debug,
    T: Debug, 

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

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

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

impl Debug for IndexPositioner

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

impl<S> Debug for Stream<S> where
    S: Debug, 

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

impl Debug for StringStreamError

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

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

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

impl<T, R> Debug for Info<T, R> where
    R: Debug,
    T: Debug, 

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

impl<S> Debug for PartialStream<S> where
    S: Debug, 

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

impl Debug for UnexpectedParse

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

impl<T, R> Debug for Info<T, R> where
    R: Debug,
    T: Debug, 

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

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

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

impl<I, X> Debug for State<I, X> where
    I: Debug,
    X: Debug, 

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 BigEndian

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

impl<L, R> Debug for Either<L, R> where
    L: Debug,
    R: Debug, 

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

impl Debug for Void

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

impl Debug for AsciiChar

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

impl Debug for AsAsciiStrError

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

impl Debug for AsciiString

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<O> Debug for FromAsciiError<O>

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

impl Debug for ToAsciiCharError

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

impl Debug for AsciiStr

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

impl<A, B, S> Debug for LinkedHashMap<A, B, S> where
    A: Eq + Debug + Hash,
    B: Debug,
    S: BuildHasher, 

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

Returns a string that lists the key-value pairs in insertion order.

impl Debug for SetLoggerError

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

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<'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 Debug for Level

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

impl Debug for ParseLevelError

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

impl<'t> Debug for Captures<'t>

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

impl Debug for CaptureLocations

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

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

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

impl<'t> Debug for Match<'t>

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

impl Debug for CaptureLocations

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

impl<'t> Debug for Match<'t>

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

impl Debug for Error

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

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

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

impl Debug for Regex

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

Shows the original regular expression.

impl<'t> Debug for Captures<'t>

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

impl Debug for SetMatches

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

impl Debug for RegexSet

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

impl Debug for SetMatches

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

impl Debug for RegexSet

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

impl Debug for Regex

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

Shows the original regular expression.

impl Debug for MatchKind

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 MatchKind

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

impl Debug for AhoCorasickBuilder

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

impl<S> Debug for AhoCorasick<S> where
    S: StateID + Debug, 

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

impl Debug for Match

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

impl<'a, 'b, S> Debug for FindIter<'a, 'b, S> where
    S: 'a + StateID + Debug, 

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

impl Debug for Builder

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 Searcher

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

impl Debug for Config

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

impl<'s, 'h> Debug for FindIter<'s, 'h>

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

impl<'a, R, S> Debug for StreamFindIter<'a, R, S> where
    R: Debug,
    S: 'a + StateID + Debug, 

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

impl<'a, 'b, S> Debug for FindOverlappingIter<'a, 'b, S> where
    S: 'a + StateID + Debug, 

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

impl Debug for TranslatorBuilder

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

impl Debug for ClassUnicode

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

impl Debug for Span

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

impl Debug for Translator

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

impl Debug for Concat

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

impl Debug for ClassBytes

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

impl Debug for Flag

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

impl Debug for LiteralKind

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

impl Debug for Printer

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

impl Debug for UnicodeWordError

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

impl Debug for GroupKind

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

impl Debug for Alternation

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

impl Debug for SpecialLiteralKind

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

impl Debug for ErrorKind

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

impl<'a> Debug for ClassBytesIter<'a>

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

impl Debug for Utf8Sequence

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

impl Debug for ClassBracketed

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

impl Debug for Utf8Range

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

impl Debug for ClassPerl

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

impl Debug for Anchor

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

impl Debug for Literal

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

impl Debug for FlagsItem

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 HirKind

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

impl Debug for Assertion

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

impl Debug for Parser

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 ClassUnicodeKind

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

impl Debug for RepetitionOp

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

impl Debug for ClassUnicodeRange

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

impl Debug for Comment

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

impl<'a> Debug for ClassUnicodeIter<'a>

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

impl Debug for Group

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

impl Debug for Flags

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

impl Debug for ClassBytesRange

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

impl Debug for ClassSetItem

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

impl Debug for Repetition

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

impl Debug for Literal

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

impl Debug for ClassSetBinaryOpKind

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

impl Debug for RepetitionRange

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

impl Debug for Literals

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

impl Debug for Hir

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

impl Debug for FlagsItemKind

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

impl Debug for Printer

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

impl Debug for Parser

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

impl Debug for CaseFoldError

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

impl Debug for ClassPerlKind

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

impl Debug for ClassAscii

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

impl Debug for Ast

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

impl Debug for ClassUnicode

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 RepetitionKind

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

impl Debug for CaptureName

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

impl Debug for ClassAsciiKind

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

impl Debug for SetFlags

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

impl Debug for ClassSetBinaryOp

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

impl Debug for HexLiteralKind

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

impl Debug for Position

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

impl Debug for AssertionKind

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

impl Debug for RepetitionKind

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 GroupKind

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

impl Debug for ClassUnicodeOpKind

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

impl Debug for WithComments

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

impl Debug for ClassSetRange

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

impl Debug for WordBoundary

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

impl Debug for RepetitionRange

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

impl Debug for Literal

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

impl Debug for ParserBuilder

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

impl Debug for Group

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 ParserBuilder

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

impl Debug for ClassSet

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

impl Debug for ClassSetUnion

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 Repetition

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

impl<T> Debug for ThreadLocal<T> where
    T: Send + Debug, 

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

impl<T> Debug for CachedThreadLocal<T> where
    T: Send + Debug, 

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

impl Debug for Certificate

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

impl Debug for Part

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

impl Debug for Request

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

impl Debug for Form

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

impl Debug for ClientBuilder

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

impl Debug for RequestBuilder

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

impl<'a> Debug for Attempt<'a>

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

impl Debug for Client

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

impl Debug for RequestBuilder

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

impl Debug for Proxy

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 Body

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

impl Debug for Request

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

impl Debug for Client

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

impl Debug for ClientBuilder

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

impl Debug for Part

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 Form

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

impl Debug for Response

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

impl Debug for Identity

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

impl Debug for Response

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

impl Debug for Policy

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

impl Debug for Body

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

impl Debug for Uri

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

impl<'a, T> Debug for GetAll<'a, T> where
    T: Debug, 

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

impl Debug for Method

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

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

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

impl Debug for Extensions

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

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

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

impl Debug for InvalidUriParts

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

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

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

impl Debug for Parts

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

impl<'a, T> Debug for Values<'a, T> where
    T: Debug, 

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

impl<'a, T> Debug for ValueIterMut<'a, T> where
    T: Debug, 

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

impl Debug for Parts

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

impl Debug for InvalidStatusCode

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

impl Debug for InvalidHeaderValue

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

impl<'a, T> Debug for ValuesMut<'a, T> where
    T: Debug, 

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

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

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 Builder

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

impl Debug for Scheme

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

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

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

impl<'a, T> Debug for ValueDrain<'a, T> where
    T: Debug, 

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 InvalidHeaderName

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

impl Debug for PathAndQuery

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

impl Debug for InvalidMethod

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

impl<'a, T> Debug for OccupiedEntry<'a, T> where
    T: Debug, 

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

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: Debug, 

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

impl Debug for InvalidUri

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

impl Debug for HeaderName

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

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

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

impl Debug for Authority

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

impl<'a, T> Debug for ValueIter<'a, T> where
    T: Debug, 

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

impl Debug for Builder

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

impl Debug for StatusCode

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

impl Debug for Parts

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

impl Debug for ToStrError

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 HeaderMap<T> where
    T: Debug, 

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

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

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

impl<'a, T> Debug for Keys<'a, T> where
    T: Debug, 

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

impl Debug for HeaderValue

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

impl Debug for Builder

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 Limit<T> where
    T: Debug, 

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

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

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for Writer<B> where
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for IoSliceMut<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Bytes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BytesMut

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for Reader<B> where
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicWaker

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for Next<'a, St> where
    St: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TrySkipWhile<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for TryJoin3<Fut1, Fut2, Fut3> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for MapErr<St, F> where
    Map<IntoStream<St>, MapErrFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for CatchUnwind<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for MapErr<Fut, F> where
    Map<IntoFuture<Fut>, MapErrFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for InspectErr<Fut, F> where
    Inspect<IntoFuture<Fut>, InspectErrFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadLine<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, E> Debug for ErrInto<Fut, E> where
    MapErr<Fut, IntoFn<E>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repeat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryBufferUnordered<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterMut<'a, Fut> where
    Fut: Unpin + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, U> Debug for MappedMutexGuard<'_, T, U> where
    T: ?Sized,
    U: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Take<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinRef<'a, Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Skip<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for SelectAll<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Flatten<St> where
    St: Stream,
    Flatten<St, <St as Stream>::Item>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for MapOk<St, F> where
    Map<IntoStream<St>, MapOkFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Fuse<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for Select<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2> Debug for TryJoin<Fut1, Fut2> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for OrElse<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, T, F> Debug for Fold<St, Fut, T, F> where
    Fut: Debug,
    St: Debug,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for MapOk<Fut, F> where
    Map<IntoFuture<Fut>, MapOkFn<F>>: 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<St, F> Debug for InspectErr<St, F> where
    Inspect<IntoStream<St>, InspectErrFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for Filter<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &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<Fut> Debug for Fuse<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for OptionFuture<F> where
    F: 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<F> Debug for PollFn<F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for TryMaybeDone<Fut> where
    Fut: Debug + TryFuture,
    <Fut as TryFuture>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for CatchUnwind<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for Then<Fut1, Fut2, F> where
    Flatten<Map<Fut1, F>, Fut2>: 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<Fut> Debug for TryFlattenStream<Fut> where
    Fut: TryFuture,
    TryFlatten<Fut, <Fut as TryFuture>::Ok>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryFlatten<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Once<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Flush<'a, W> where
    W: 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<'a, R> Debug for ReadToString<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for SelectNextSome<'a, St> where
    St: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for TrySelect<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for SelectAll<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for UnwrapOrElse<Fut, F> where
    Map<IntoFuture<Fut>, UnwrapOrElseFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Write<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for OrElse<Fut1, Fut2, F> where
    TryFlattenErr<MapErr<Fut1, F>, Fut2>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for FilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for TryNext<'a, St> where
    St: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for Join3<Fut1, Fut2, Fut3> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for SelectOk<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, U, F> Debug for FlatMap<St, U, F> where
    Flatten<Map<St, F>, U>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TakeWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Enumerate<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Window<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for FuturesUnordered<Fut>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for Read<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadVectored<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for Flatten<F> where
    F: Future,
    Flatten<F, <F as Future>::Output>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for Then<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for TryJoinAll<F> where
    F: TryFuture + Debug,
    <F as TryFuture>::Ok: Debug,
    <F as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for NeverError<Fut> where
    Map<Fut, OkFn<Infallible>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2> Debug for Zip<St1, St2> where
    St1: Debug + Stream,
    St2: Debug + Stream,
    <St1 as Stream>::Item: Debug,
    <St2 as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for IntoAsyncRead<St> where
    St: Debug + TryStream<Error = Error> + Unpin,
    <St as TryStream>::Ok: AsRef<[u8]>,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadUntil<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, E> Debug for ErrInto<St, E> where
    MapErr<St, IntoFn<E>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2> Debug for Join<Fut1, Fut2> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Aborted

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for InspectOk<St, F> where
    Inspect<IntoStream<St>, InspectOkFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for JoinAll<F> where
    F: Future + Debug,
    <F as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, St> Debug for Peek<'_, St> where
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Buffered<St> where
    St: Stream + Debug,
    <St as Stream>::Item: Future, 

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<Fut1, Fut2> Debug for TryFlatten<Fut1, Fut2> where
    TryFlatten<Fut1, Fut2>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for MaybeDone<Fut> where
    Fut: Debug + Future,
    <Fut as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryTakeWhile<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

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<'a, W> Debug for WriteAll<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Map<St, F> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for IntoStream<F> where
    Once<F>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, Fut> Debug for TryUnfold<T, F, Fut> where
    Fut: Debug,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for Map<Fut, F> where
    Map<Fut, F>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Shared<Fut> where
    Fut: Future, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F, G> Debug for MapOkOrElse<Fut, F, G> where
    Map<IntoFuture<Fut>, ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2> Debug for Select<St1, St2> where
    St1: Debug,
    St2: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for Inspect<Fut, F> where
    Map<Fut, InspectFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilter<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for ReadyChunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadExact<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for StreamFuture<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for AllowStdIo<T> where
    T: 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<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for TryJoin5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    Fut5: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug,
    <Fut5 as TryFuture>::Ok: Debug,
    <Fut5 as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, T, F> Debug for TryFold<St, Fut, T, F> where
    Fut: Debug,
    St: Debug,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, T> Debug for MapInto<Fut, T> where
    Map<Fut, IntoFn<T>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for Join5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    Fut5: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug,
    <Fut5 as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadToEnd<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, W> Debug for Copy<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for Iter<'a, Fut> where
    Fut: Unpin + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Take<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for WriteVectored<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut> Debug for TakeUntil<St, Fut> where
    Fut: Future + Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for BufferUnordered<St> where
    St: Stream + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Abortable<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Close<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for Either<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for InspectOk<Fut, F> where
    Inspect<IntoFuture<Fut>, InspectOkFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, E> Debug for OkInto<Fut, E> where
    MapOk<Fut, IntoFn<E>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, W> Debug for CopyBuf<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for Seek<'a, S> where
    S: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Chunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for AndThen<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2> Debug for Chain<St1, St2> where
    St1: Debug,
    St2: 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, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for AndThen<Fut1, Fut2, F> where
    TryFlatten<MapOk<Fut1, F>, Fut2>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, C> Debug for Collect<St, C> where
    C: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, C> Debug for TryCollect<St, C> where
    C: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinMut<'a, Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Peekable<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for TryJoin4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    Fut: Debug,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReuniteError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryConcat<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for Join4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Concat<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for FlattenStream<F> where
    F: Future,
    Flatten<F, <F as Future>::Output>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for Lazy<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AbortRegistration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for FuturesOrdered<Fut> where
    Fut: Future, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for IntoFuture<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Lines<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Inspect<St, F> where
    Map<St, InspectFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for UnitError<Fut> where
    Map<Fut, OkFn<()>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sink

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, S, Fut, F> Debug for Scan<St, S, Fut, F> where
    Fut: Debug,
    S: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for MutexLockFuture<'_, T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AbortHandle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for IntoStream<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for MutexGuard<'_, T> where
    T: Debug + ?Sized, 

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<St, Fut, F> Debug for SkipWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: 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<'_, T> Debug for LocalFutureObj<'_, T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for FutureObj<'_, T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for WakerRef<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpawnError

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 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<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Trailers<'a, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Data<'a, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SizeHint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Registration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Delay

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BarrierWaitResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Runtime

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for JoinHandle<T> where
    T: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpListener

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Handle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClosedError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DelayQueue<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SemaphorePermit<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OwnedSemaphorePermit

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OwnedWriteHalf

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<R> Debug for BufReader<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RwLockWriteGuard<'a, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for MutexGuard<'_, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Expired<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for JoinError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Empty<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Split<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: Debug + ?Sized, 

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 TcpStream

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: 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<T> Debug for UnboundedSender<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TrySendError<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OwnedMutexGuard<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Incoming<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReuniteError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ReadHalf<'a>

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<'a, R, W> Debug for Copy<'a, R, W> where
    R: Debug + ?Sized,
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repeat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Lines<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RwLock<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryLockError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Take<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for WriteHalf<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Key

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for StreamMap<K, V> where
    K: Debug,
    V: Debug, 

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 Builder

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Elapsed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RwLockReadGuard<'a, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for PollEvented<E> where
    E: Debug + Evented, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Throttle<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Barrier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Instant

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendTimeoutError<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OwnedReadHalf

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for Seek<'a, S> where
    S: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Semaphore

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, B> Debug for StreamReader<S, B> where
    B: Debug,
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Ref<'a, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Notify

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sink

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryCurrentError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Timeout<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Interval

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<RW> Debug for BufStream<RW> where
    RW: Debug, 

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 TcpListener

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetReadiness

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Iter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Poll

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Events

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 Ready

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for EventedFd<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PollOpt

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Token

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixReady

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Registration

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Event

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UdpBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GaiFuture

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ResponseFuture

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Http<E> where
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GaiAddrs

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, S> Debug for Server<I, S, Exec> where
    I: Debug,
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Connected

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Name

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GaiResolver

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F, E> Debug for Connecting<I, F, E> where
    E: Debug,
    F: Debug,
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ResponseFuture

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnUpgrade

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Body + 'static,
    T: AsyncRead + AsyncWrite + Debug + Send + 'static, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Parts<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, E> Debug for Builder<I, E> where
    E: Debug,
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<C, B> Debug for Client<C, B>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AddrIncoming

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidNameError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Upgraded

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for HttpConnector<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AddrStream

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for Parts<T, S> where
    S: Debug,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<C, B, T> Debug for Connect<C, B, T> where
    B: Debug,
    C: Debug,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, S> Debug for Connection<I, S, Exec> where
    S: HttpService<Body>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Body

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendRequest<B>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sender

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Parts<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Span

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Entered<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for WithDispatch<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Instrumented<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

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<'a> Debug for Attributes<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Current

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetGlobalDefaultError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelFilterError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Kind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for dyn Value + 'static

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Field

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LevelFilter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Id

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 Level

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugValue<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Dispatch

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 DefaultGuard

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DisplayValue<T> where
    T: Display, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ValueSet<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Iter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Event<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FieldSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Interest

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

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 Canceled

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Cancellation<'a, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SendError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

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 Domain

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 Socket

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 Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpDate

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for ReadySendRequest<B> where
    B: Debug + Buf, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PingPong

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Reason

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendPushedResponse<B> where
    B: Debug + Buf, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Debug + Buf,
    T: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PushPromise

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendRequest<B> where
    B: Buf, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvStream

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendResponse<B> where
    B: Debug + Buf, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FlowControl

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ping

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ResponseFuture

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pong

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B> where
    B: Debug + Buf,
    T: AsyncRead + AsyncWrite + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendStream<B> where
    B: Debug + Buf, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PushedResponseFuture

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StreamId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Debug + Buf,
    T: AsyncRead + AsyncWrite + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PushPromises

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for FramedParts<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LengthDelimitedCodec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BytesCodec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, D> Debug for FramedRead<T, D> where
    D: Debug,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LinesCodec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for FramedWrite<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for Framed<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LengthDelimitedCodecError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LinesCodecError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Giver

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Taker

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SharedGiver

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Closed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TryLock<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Locked<'a, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidChunkSize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Status<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Header<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'headers, 'buf> Debug for Response<'headers, 'buf> where
    'buf: 'headers, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'headers, 'buf> Debug for Request<'headers, 'buf> where
    'buf: 'headers, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for HandshakeError<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for MidHandshakeTlsStream<S> where
    S: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for TlsStream<S> where
    S: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Protocol

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TimeDiff

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Asn1StringRef

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigNum

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OcspRevokedStatus

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 X509NameRef

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Nid

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpensslString

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslVerifyMode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GeneralNameRef

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for MidHandshakeSslStream<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClientHelloResponse

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslRef

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ShutdownResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for HandshakeError<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslContext

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ssl

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ShutdownState

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Dsa<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslAlert

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OcspFlag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Stack<T> where
    T: Stackable,
    <T as ForeignType>::Ref: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for EcKey<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslSessionCacheMode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Asn1ObjectRef

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigNumRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for KeyIvPair

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Id

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DigestBytes

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AlpnError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SniError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorStack

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorCode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslConnector

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Rsa<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslOptions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SrtpProfileId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Asn1TimeRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for X509VerifyResult

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CMSOptions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for X509

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pkcs7Flags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslVersion

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SslMode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for KeyError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExtensionContext

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Padding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for X509CheckFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for SslStream<S> where
    S: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PKey<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OcspCertStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OcspResponseStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for X509NameEntryRef

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpensslStringRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IterRaw

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Iter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MimeGuess

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 Mime

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Params<'a>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromStrError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Ascii<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for UniCase<S> where
    S: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for EncoderWriter<'a, W> where
    W: Write, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for DecoderReader<'a, R> where
    R: Read, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodeError

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 CharacterSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Latin1Bidi

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecoderResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EncoderResult

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 CoderResult

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 TlsAcceptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for TlsStream<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TlsConnector

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IpAddrRange

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 IpSubnets

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ipv6AddrRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ipv4Net

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ipv6Subnets

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ipv4AddrRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ipv6Net

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IpNet

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ipv4Subnets

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PrefixLenError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for HttpsConnector<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for HttpsConnecting<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for MaybeHttpsStream<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ColorChoice

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseColorError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Color

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ColorSpec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Applicability

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Resolve

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Target

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PackageId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Package

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Diagnostic

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Artifact

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Message

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CargoOpt

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Metadata

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiagnosticCode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiagnosticSpanMacroExpansion

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BuildScript

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DependencyKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ArtifactProfile

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeDep

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Source

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DepKindInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiagnosticSpan

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompilerMessage

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiagnosticLevel

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 MetadataCommand

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiagnosticSpanLine

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Dependency

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Node

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Map<String, Value>

pub fn fmt(&self, formatter: &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 CompactFormatter

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 Value

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Context<D> where
    D: 'static + Send + Sync + Display, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Compat<E> where
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SyncFailure<T> where
    T: Debug, 

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 Backtrace

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepositoryInitMode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CheckoutNotificationType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ObjectType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MergeAnalysis

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'buffers> Debug for Patch<'buffers>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RebaseOperationType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'repo> Debug for Object<'repo>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sort

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepositoryOpenFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StashApplyProgress

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiffStatsFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiffBinaryKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileMode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Status

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReferenceFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexEntryExtendedFlag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'repo> Debug for Blob<'repo>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for DiffHunk<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileFavor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ConfigLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Oid

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CredentialType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PackBuilderStage

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiffStats

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorClass

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for DiffDelta<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StashApplyFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepositoryState

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MergePreference

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'repo> Debug for Tree<'repo>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SubmoduleStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'repo> Debug for Tag<'repo>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReferenceType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ApplyLocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for DiffLine<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'repo> Debug for Commit<'repo>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexEntryFlag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorCode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexAddOption

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 StashFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DiffFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'rebase> Debug for RebaseOperation<'rebase>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for DiffFile<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RevparseMode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BranchType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Delta

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AttrCheckFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'repo> Debug for OidArray

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'repo> Debug for Note<'repo>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PathspecFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stream

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PopenConfig

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NullFile

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExitStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CommunicateError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Communicator

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Popen

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pipeline

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Redirection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PopenError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Exec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromHexError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Index

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Dependency

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 DependencyKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Crate

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 ReqParseError

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 VersionReq

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<'input> Debug for Lexer<'input>

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 Identifier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Comparator

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 Op

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 Range

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'input> Debug for Token<'input>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'input> Debug for Error<'input>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RangeSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Compat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ErrorVariant<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i> Debug for Position<'i>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for Pairs<'i, R> where
    R: RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Error<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InputLocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i> Debug for Span<'i>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for Tokens<'i, R> where
    R: RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Lookahead

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for Token<'i, R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Assoc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PrecClimber<R> where
    R: RuleType + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Operator<R> where
    R: RuleType + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for FlatPairs<'i, R> where
    R: RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for Pair<'i, R> where
    R: RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Atomicity

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MatchDir

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LineColLocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for ParserState<'i, R> where
    R: RuleType + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for TrieSetSlice<'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 TrieSetOwned

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Mode> Debug for SmartString<Mode> where
    Mode: SmartStringMode, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Compact

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LazyCompact

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Mode> Debug for Drain<'a, Mode> where
    Mode: SmartStringMode, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GlobError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pattern

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PatternError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ast

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeHeading

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeHtmlBlock

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ReverseChildren<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Children<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ListDelimType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Anchorizer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeLink

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ComrakOptions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Ancestors<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeDescriptionItem

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ComrakParseOptions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for PrecedingSiblings<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Descendants<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeCodeBlock

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TableAlignment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ReverseTraverse<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for FollowingSiblings<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ComrakExtensionOptions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for NodeEdge<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ComrakRenderOptions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeList

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Node<'a, T> where
    T: 'a + Debug, 

A simple Debug implementation that prints the children as a tree, without ilooping through the various interior pointer cycles.

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeValue

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Traverse<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ListType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Codepoints

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Entity

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SmolStr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Loading content...

Implementors

impl Debug for rustsec::advisory::category::Category

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Severity

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for rustsec::advisory::id::Kind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Informational

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::advisory::linter::ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Collection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Registry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::error::ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for ResolveVersion

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 Checksum

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GitReference

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for rustsec::warning::Kind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Affected

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for FunctionPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::advisory::affected::Identifier

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::advisory::date::Date

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::advisory::id::Id

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Keyword

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::advisory::linter::Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Linter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::advisory::metadata::Metadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Advisory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Versions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::database::scope::Package

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Database

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Query

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::error::Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Lockfile

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for rustsec::package::checksum::fmt::Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for rustsec::package::Name

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for rustsec::package::Package

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SourceId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DatabaseInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for LockfileInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Report

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Settings

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for VulnerabilityInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Signature

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::repository::Commit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for rustsec::Version

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for rustsec::VersionReq

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Vulnerability

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Warning

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<'_> Debug for Arguments<'_>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

Loading content...