Trait validators::prelude::validators_prelude::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.

Types that do not wish to use the standard suite of debug representations provided by the Formatter trait (debug_struct, debug_tuple, debut_list, debug_set, debug_map) can do something totally custom by manually writing an arbitrary representation to the Formatter.

impl fmt::Debug for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Point [{} {}]", self.x, self.y)
    }
}

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

Implementations on Foreign Types

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

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

impl Debug for Permissions

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

impl Debug for Stderr

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

impl Debug for Error

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

impl<T> Debug for Key<T>

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

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

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, 

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

impl<T> Debug for SendError<T>

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

impl Debug for WriterPanicked

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

impl Debug for AncillaryError

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

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

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

impl<'a> Debug for IoSliceMut<'a>

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

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

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

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

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

impl Debug for BacktraceStyle

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

impl Debug for OpenOptions

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

impl Debug for Barrier

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

impl<T> Debug for PoisonError<T>

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

impl Debug for CStr

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

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

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

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

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

impl Debug for SeekFrom

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

impl<T> Debug for SyncSender<T>

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

impl Debug for Command

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

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

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

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

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

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

impl Debug for Condvar

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

impl Debug for VarsOs

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

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

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

impl Debug for Ipv6MulticastScope

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

impl Debug for TcpStream

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

impl Debug for SocketAddrV4

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

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

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

impl Debug for Once

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

impl Debug for UnixDatagram

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

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

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

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

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

impl<T> Debug for TryLockError<T>

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

impl Debug for Sink

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

impl Debug for RecvTimeoutError

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

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

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

impl Debug for UdpSocket

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

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

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

impl Debug for DefaultHasher

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

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

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

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

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

impl<T> Debug for JoinHandle<T>

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

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

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

impl Debug for Vars

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

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

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

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

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

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

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

impl Debug for ReadDir

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

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

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

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

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

impl Debug for Child

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

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

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

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

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

impl Debug for IntoStringError

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

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

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

impl Debug for WaitTimeoutResult

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

impl Debug for UCred

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

impl Debug for AddrParseError

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

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

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

impl Debug for Stdout

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

impl Debug for File

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

impl<T> Debug for Key<T>

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

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

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

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

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

impl Debug for ExitStatusError

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

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

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

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

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

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

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

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

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

impl<'_, '_> Debug for Scope<'_, '_>

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

impl Debug for Stdio

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

impl Debug for Shutdown

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

impl Debug for ChildStdout

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

impl Debug for Instant

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

impl Debug for BacktraceFrame

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

impl Debug for JoinPathsError

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

impl Debug for DirEntry

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

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

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

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

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

impl<'scope, T> Debug for ScopedJoinHandle<'scope, T>

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

impl Debug for ThreadId

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

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

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

impl Debug for Repeat

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

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

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

impl Debug for OwnedFd

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

impl Debug for FromVecWithNulError

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

impl<'_> Debug for BorrowedFd<'_>

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

impl Debug for StripPrefixError

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

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

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

impl Debug for NulError

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

impl Debug for SystemTime

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

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

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

impl Debug for UnixStream

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

impl Debug for FileType

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

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

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

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

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

impl Debug for Thread

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

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

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

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

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

impl Debug for Builder

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

impl Debug for ExitStatus

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

impl Debug for Output

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

impl<E> Debug for Report<E> where
    Report<E>: Display, 

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

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

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

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

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

impl<'_> Debug for ReadBuf<'_>

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

impl Debug for SocketAddrV6

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

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

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

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

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

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

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

impl Debug for RandomState

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

impl Debug for FromBytesWithNulError

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

impl Debug for RecvError

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

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

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

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

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

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

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

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

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

impl Debug for BarrierWaitResult

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

impl Debug for Metadata

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

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

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

impl Debug for OsStr

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

impl Debug for Stdin

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

impl<T> Debug for Sender<T>

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

impl Debug for Backtrace

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

impl Debug for ExitCode

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

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

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

impl Debug for OnceState

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

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

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

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

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

impl Debug for PidFd

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

impl<T> Debug for TrySendError<T>

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

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

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

impl Debug for ChildStdin

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

impl Debug for Args

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

impl Debug for OsString

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

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

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

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

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

impl Debug for SocketAddr

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

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

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

impl Debug for BacktraceStatus

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

impl Debug for PathBuf

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

impl Debug for IntoIncoming

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

impl Debug for AccessError

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

impl Debug for SystemTimeError

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

impl Debug for TcpListener

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

impl Debug for ChildStderr

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

impl Debug for ErrorKind

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

impl Debug for System

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

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

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

impl Debug for DirBuilder

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

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

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

impl Debug for SocketAddr

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

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

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

impl Debug for CString

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

impl<'a> Debug for SocketAncillary<'a>

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

impl Debug for TryRecvError

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

impl Debug for ArgsOs

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

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

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

impl Debug for VarError

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

impl<T> Debug for Receiver<T>

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

impl Debug for Empty

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

impl Debug for UnixListener

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

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

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

impl Debug for Path

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

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

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

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

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

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

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

impl Debug for u64

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

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

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

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

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

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

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

impl<'a, 'b, const N: usize> Debug for CharArrayRefSearcher<'a, 'b, N>

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

impl Debug for TryFromCharError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroI64

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

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

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

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

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

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

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

impl Debug for Utf8Error

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

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

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

impl Debug for __m512d

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

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

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroU32

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

impl Debug for __m128

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

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

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

impl Debug for TryFromSliceError

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

impl Debug for RangeFull

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

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

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

impl Debug for ToUppercase

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

impl Debug for __m256d

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

impl Debug for AtomicBool

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

impl Debug for i64

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

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

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

impl Debug for TypeId

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroU128

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

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

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

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

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

impl Debug for ParseIntError

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

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

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

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

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

impl<F> Debug for PollFn<F>

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

impl Debug for AtomicI16

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

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

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

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

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

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

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

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

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

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

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

impl Debug for ()

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

impl Debug for NonZeroI16

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

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

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

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

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

impl Debug for ParseBoolError

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

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

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

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

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

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

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

impl Debug for IntErrorKind

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

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

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

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

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

impl Debug for NonZeroI128

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

impl Debug for i8

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

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

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

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

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

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

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

impl Debug for __m256i

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

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

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

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

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

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

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

impl Debug for usize

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for __m512i

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

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

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

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

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

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

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

impl Debug for NonZeroI8

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

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

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

impl Debug for Infallible

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

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

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

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

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

impl Debug for EscapeDebug

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

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

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

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

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

impl Debug for NonZeroU8

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

impl<T> Debug for Cell<T> where
    T: Copy + Debug, 

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

impl Debug for AtomicIsize

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for CpuidResult

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

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

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

impl Debug for ParseFloatError

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

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

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

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

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

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

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

impl Debug for NonZeroI32

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

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

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

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

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

impl Debug for Duration

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

impl Debug for str

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

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

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

impl Debug for AtomicU8

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

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

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

impl Debug for FpCategory

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

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

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

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

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

impl Debug for AtomicUsize

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

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

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

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

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

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

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

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

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

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

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

impl Debug for ParseCharError

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

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

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

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

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

impl Debug for AtomicU16

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

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

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

impl<T> Debug for Empty<T>

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

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

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

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

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

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

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

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

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

impl Debug for Ordering

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

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

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

impl Debug for __m128i

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

impl<H> Debug for BuildHasherDefault<H>

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

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

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

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

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

impl<'a, const N: usize> Debug for CharArraySearcher<'a, N>

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

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

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

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

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

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

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

impl<T> Debug for Ready<T>

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

impl Debug for EscapeDefault

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

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

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

impl<T, const LANES: usize> Debug for Mask<T, LANES> where
    T: MaskElement + Debug,
    LaneCount<LANES>: SupportedLaneCount, 

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

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

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

impl Debug for AtomicI64

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

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

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

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

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

impl Debug for Which

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

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

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

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

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

impl Debug for NonZeroUsize

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

impl Debug for BorrowError

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

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

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

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

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

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

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

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

impl<T> Debug for Pending<T>

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

impl Debug for __m128bh

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

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

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

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

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

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

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

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

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

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

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

impl<T> Debug for AtomicPtr<T>

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

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

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

impl Debug for char

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for SipHasher

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

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

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

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

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

impl Debug for u128

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

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

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

impl Debug for c_void

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

impl Debug for u32

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

impl<F> Debug for FromFn<F>

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

impl Debug for TryFromIntError

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

impl Debug for Layout

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

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

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

impl Debug for DecodeUtf16Error

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

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

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

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

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

impl Debug for RawWakerVTable

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

impl Debug for NonZeroU16

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

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

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

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

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

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

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

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

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

impl Debug for AtomicU32

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

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

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

impl<Dyn> Debug for DynMetadata<Dyn> where
    Dyn: ?Sized, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for EscapeUnicode

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

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

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

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

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

impl Debug for EscapeDefault

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for LayoutError

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

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

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

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

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

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

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

impl Debug for __m512

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

impl Debug for AllocError

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

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

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

impl Debug for dyn Any + 'static

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

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

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

impl<T> Debug for Discriminant<T>

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

impl Debug for FromFloatSecsError

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

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

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

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

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

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

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

impl Debug for bool

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

impl Debug for __m512bh

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

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

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

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

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

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

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

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

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

impl Debug for i16

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

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

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

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

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

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

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

impl Debug for RawWaker

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

impl<T, const LANES: usize> Debug for Simd<T, LANES> where
    T: SimdElement + Debug,
    LaneCount<LANES>: SupportedLaneCount, 

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

impl Debug for u8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for PhantomPinned

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

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

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

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

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

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

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

impl Debug for u16

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

impl Debug for f64

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

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

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

impl Debug for CharTryFromError

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

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

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

impl Debug for Waker

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

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

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

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

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

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

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

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

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

impl Debug for BorrowMutError

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

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

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

impl Debug for !

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

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

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

impl Debug for __m256bh

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

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

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

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

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

impl Debug for i32

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

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

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

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

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

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

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

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

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

impl<'a> Debug for EscapeAscii<'a>

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

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

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

impl Debug for __m128d

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

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

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

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

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

impl Debug for __m256

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

impl Debug for AtomicU64

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

impl Debug for isize

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

impl Debug for i128

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

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

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

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

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

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

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

impl Debug for NonZeroU64

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

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

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

impl Debug for f32

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

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

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

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

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

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

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

impl Debug for AtomicI8

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

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

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

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

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

impl Debug for Utf8Lossy

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

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

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

impl<T> Debug for MaybeUninit<T>

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

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

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

impl Debug for AtomicI32

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

impl Debug for Ordering

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

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

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

impl Debug for ToLowercase

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroIsize

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

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

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

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

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

impl Debug for SearchStep

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

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

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

impl Debug for dyn Any + Send + 'static

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'_, T, F> Debug for DrainFilter<'_, T, F> where
    T: Debug,
    F: FnMut(&mut T) -> bool, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Entry<'_, K, V> where
    K: Debug + Ord,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, F, A> Debug for DrainFilter<'a, T, F, A> where
    T: Debug,
    F: Debug + FnMut(&mut T) -> bool,
    A: Debug + Allocator, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, F> Debug for DrainFilter<'_, K, V, F> where
    K: Debug,
    V: Debug,
    F: FnMut(&K, &mut V) -> bool, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoValues<K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for BinaryHeap<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for OccupiedError<'_, K, V> where
    K: Debug + Ord,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Union<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromUtf16Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LinkedList<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I, A> Debug for Splice<'a, I, A> where
    I: 'a + Debug + Iterator,
    A: 'a + Debug + Allocator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for IntoIter<T, A> where
    T: Debug,
    A: Allocator, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Difference<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Cursor<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for PeekMut<'_, T> where
    T: Ord + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Drain<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Intersection<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for SymmetricDifference<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryReserveErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for DrainSorted<'a, T> where
    T: Debug + Ord, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for VecDeque<T, A> where
    T: Debug,
    A: Allocator, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, F> Debug for DrainFilter<'_, T, F> where
    T: Debug,
    F: FnMut(&T) -> bool, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for IntoIter<T, A> where
    T: Debug,
    A: Allocator, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Range<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, A> Debug for Drain<'_, T, A> where
    T: Debug,
    A: Allocator, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Global

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryReserveError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for BTreeSet<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for CursorMut<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromUtf8Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for RangeMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Debug + Ord, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for _Unwind_Reason_Code

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodeError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodePartial

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpecificationError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Specification

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Encoding

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Translate

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BitOrder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodeKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Wrap

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Errors

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'text> Debug for BidiInfo<'text>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParagraphInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'text> Debug for InitialInfo<'text>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BidiClass

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IsNormalized

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryFromSliceError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s, T> Debug for SliceVec<'s, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for TinyVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for TinyVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompactFormatter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Map<String, Value>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Number

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Category

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U128Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    I: Debug, 

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for BytesDeserializer<'a, E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IgnoredAny

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I128Deserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Carrier

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Descriptor

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Database

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Validation

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Defaults

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Descriptors

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Metadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Mode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Id

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Metadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parse

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PhoneNumber

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Source

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Format

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Descriptor

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Extension

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Code

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'n, 'd, 'f> Debug for Formatter<'n, 'd, 'f>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Format

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Metadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NationalNumber

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VerboseErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Needed

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Endianness

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompareResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Err<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for VerboseError<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'n> Debug for FinderRev<'n>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Prefilter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'h, 'n> Debug for FindRevIter<'h, 'n>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'h, 'n> Debug for FindIter<'h, 'n>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FinderBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'n> Debug for Finder<'n>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CapacityError<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSetBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SetMatchesIter<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SetMatchesIter<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Split<'r, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Match<'t>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Regex

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Shows the original regular expression.

impl<'r, 't> Debug for Matches<'r, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Regex

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Shows the original regular expression.

impl<'c, 't> Debug for SubCaptureMatches<'c, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureLocations

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for NoExpand<'t>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureLocations

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for CaptureMatches<'r, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for CaptureNames<'r>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSet

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatchesIntoIter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c, 't> Debug for SubCaptureMatches<'c, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for CaptureNames<'r>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for SplitN<'r, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Matches<'r, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for NoExpand<'t>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatches

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Split<'r, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSetBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for SplitN<'r, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatches

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Match<'t>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatchesIntoIter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSet

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for CaptureMatches<'r, 't>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Alternation

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassPerlKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpecialLiteralKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Anchor

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Flag

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBytes

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Class

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSet

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Span

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GroupKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassPerl

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureName

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBracketed

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Hir

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBytesRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetUnion

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GroupKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetItem

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HexLiteralKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Assertion

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Concat

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Printer

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repetition

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Comment

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LiteralKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TranslatorBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WithComments

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeOpKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Group

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ast

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassAsciiKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Sequence

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Sequences

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parser

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FlagsItem

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repetition

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Range

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AssertionKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HirKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Printer

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Class

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literals

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parser

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetBinaryOpKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnicodeWordError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaseFoldError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Group

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Flags

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FlagsItemKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetBinaryOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WordBoundary

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ClassUnicodeIter<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassAscii

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Translator

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ClassBytesIter<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MatchKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindIter<'a, 'b, S> where
    S: Debug + StateID, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, S> Debug for StreamFindIter<'a, R, S> where
    R: Debug,
    S: Debug + StateID, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Searcher

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for AhoCorasick<S> where
    S: Debug + StateID, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindOverlappingIter<'a, 'b, S> where
    S: Debug + StateID, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MatchKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AhoCorasickBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s, 'h> Debug for FindIter<'s, 'h>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Match

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LazyRegexBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CachedRegex

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LazyRegex

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CachedRegexBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S> Debug for LruCache<K, V, S> where
    K: Debug + Eq + Hash,
    V: Debug,
    S: BuildHasher, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B, S> Debug for LinkedHashMap<A, B, S> where
    A: Debug + Hash + Eq,
    B: Debug,
    S: BuildHasher, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Returns a string that lists the key-value pairs in insertion order.

impl<'a> Debug for BytesStart<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for BytesText<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for BytesDecl<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Attribute<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for BytesEnd<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Event<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for PutBackN<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Combinations<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for PutBack<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for MultiPeek<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for KMergeBy<I, F> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for Coalesce<I, F> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for WhileSome<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I> Debug for Format<'a, I> where
    I: Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for ZipEq<I, J> where
    I: Debug,
    J: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, Pred> Debug for DedupBy<I, Pred> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Unique<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Hash,
    <I as Iterator>::Item: Eq,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J, F> Debug for MergeJoinBy<I, J, F> where
    I: Iterator + Debug,
    J: Iterator + Debug,
    <I as Iterator>::Item: Debug,
    <J as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for ConsTuples<I, J> where
    I: Debug + Iterator<Item = J>,
    J: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for Batching<I, F> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J, F> Debug for MergeBy<I, J, F> where
    I: Iterator + Debug,
    J: Iterator<Item = <I as Iterator>::Item> + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I, E> Debug for ProcessResults<'a, I, E> where
    I: Debug,
    E: 'a + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for Interleave<I, J> where
    I: Debug,
    J: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for RcIter<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Zip<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, T> Debug for TupleCombinations<I, T> where
    I: Debug + Iterator,
    T: Debug + HasCombination<I>,
    <T as HasCombination<I>>::Combination: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Tee<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for ZipLongest<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for CombinationsWithReplacement<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug,
    <I as Iterator>::Item: Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I, F> Debug for TakeWhileRef<'a, I, F> where
    I: Iterator + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for Product<I, J> where
    I: Debug + Iterator,
    J: Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for InterleaveShortest<I, J> where
    I: Debug + Iterator,
    J: Debug + Iterator<Item = <I as Iterator>::Item>, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Permutations<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for FoldWhile<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Step<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Position<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Intersperse<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for RepeatN<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, V, F> Debug for UniqueBy<I, V, F> where
    I: Iterator + Debug,
    V: Debug + Hash + Eq, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Iterate<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, T> Debug for TupleWindows<I, T> where
    I: Debug + Iterator<Item = <T as TupleCollect>::Item>,
    T: Debug + HomogeneousTuple, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for EitherOrBoth<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for ExactlyOneError<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Unfold<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for RepeatCall<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TupleBuffer<T> where
    T: Debug + HomogeneousTuple,
    <T as TupleCollect>::Buffer: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for MinMaxResult<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<L, R> Debug for Either<L, R> where
    L: Debug,
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Comparator

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BuildMetadata

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Prerelease

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Op

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VersionReq

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Host<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SyntaxViolation

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpaqueOrigin

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for UrlQuery<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Origin

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PathSegmentsMut<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Url

Debug the serialization of this URL.

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ByteSerialize<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PercentDecode<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Ascii<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for UniCase<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Entity

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Request<'_>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Strict<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Unauthorized<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sig

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for ByteStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileName

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Feature

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for NameBuf<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NamedFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for MsgPack<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Accepted<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Response<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for ReaderStream<S> where
    S: Stream + Debug,
    <S as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for LocalResponse<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for NameView<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Limits

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Redirect

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TlsConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for LocalRequest<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for JavaScript<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Kind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Custom<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Info

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for LocalResponse<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for CookieJar<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Plain<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Route

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for Body<'r>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Catcher

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Created<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Options

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Css<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NoContent

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'v> Debug for Context<'v>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LogLevel

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Allow

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Debug<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for RouteUri<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Form<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<P> Debug for Rocket<P> where
    P: Phase, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Key

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for NotFound<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Name

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Options

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for TextStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Conflict<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for State<T> where
    T: 'static + Debug + Send + Sync, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Json<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BadRequest<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Html<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'v> Debug for ErrorKind<'v>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, E, F> Debug for Outcome<S, E, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Custom<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileServer

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ident

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Lenient<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'v> Debug for Errors<'v>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'v> Debug for TempFile<'v>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Flash<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Forbidden<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Capped<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for LocalRequest<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for N

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'v, T> Debug for Contextual<'v, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Xml<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Color

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Paint<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Style

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicWaker

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryConcat<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Iter<I> where
    I: Debug, 

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, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Once<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for IterMut<'a, St> where
    St: Debug + Unpin, 

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, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for FilterMap<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReuniteError<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for IntoAsyncRead<St> where
    St: Debug + TryStream<Error = Error> + Unpin,
    <St as TryStream>::Ok: AsRef<[u8]>,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Si, Item> Debug for Feed<'a, Si, Item> where
    Si: Debug + ?Sized,
    Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, Fut> Debug for TryUnfold<T, F, Fut> where
    T: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Empty<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, Item, E> Debug for SinkErrInto<Si, Item, E> where
    Si: Debug + Sink<Item>,
    Item: Debug,
    E: Debug,
    <Si as Sink<Item>>::Error: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Enumerate<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for FuturesOrdered<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEach<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Buffered<St> where
    St: Stream + Debug,
    <St as Stream>::Item: Future, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, St, T> Debug for NextIfEq<'_, St, T> where
    St: Stream + Debug,
    T: ?Sized,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2> Debug for Chain<St1, St2> where
    St1: Debug,
    St2: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, W> Debug for Copy<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilter<St, Fut, F> where
    St: TryStream + Debug,
    Fut: Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Cursor<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for SkipWhile<St, Fut, F> where
    St: Stream + Debug,
    Fut: Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for UnitError<Fut> where
    Map<Fut, OkFn<()>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for Either<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadVectored<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Repeat<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for WriteAll<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for WeakShared<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, St> Debug for Peek<'_, St> where
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PollNext

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sink

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2> Debug for Join<Fut1, Fut2> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si1, Si2> Debug for Fanout<Si1, Si2> where
    Si1: Debug,
    Si2: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilterMap<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for Inspect<Fut, F> where
    Map<Fut, InspectFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Drain<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Write<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for TryJoin5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    Fut5: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug,
    <Fut5 as TryFuture>::Ok: Debug,
    <Fut5 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for PollImmediate<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for MutexLockFuture<'_, T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut> Debug for TakeUntil<St, Fut> where
    St: Stream + Debug,
    Fut: Future + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for Iter<'a, St> where
    St: Debug + Unpin, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEachConcurrent<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Concat<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, St> Debug for PeekMut<'_, St> where
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for IntoStream<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for TrySelect<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, Item> Debug for ReuniteError<T, Item>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for SelectAll<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for MaybeDone<Fut> where
    Fut: Debug + Future,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for AllowStdIo<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2> Debug for Select<St1, St2> where
    St1: Debug,
    St2: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, Item, U, Fut, F> Debug for With<Si, Item, U, Fut, F> where
    Si: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryBuffered<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: TryFuture,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for FuturesUnordered<Fut>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Si, Item> Debug for Send<'a, Si, Item> where
    Si: Debug + ?Sized,
    Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, St, F> Debug for NextIf<'_, St, F> where
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, R> Debug for Unfold<T, F, R> where
    T: Debug,
    F: Debug,
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinMut<'a, Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for InspectOk<Fut, F> where
    Inspect<IntoFuture<Fut>, InspectOkFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, E> Debug for ErrInto<St, E> where
    MapErr<St, IntoFn<E>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryBufferUnordered<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for NeverError<Fut> where
    Map<Fut, OkFn<Infallible>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for MapErr<Fut, F> where
    Map<IntoFuture<Fut>, MapErrFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, S, Fut, F> Debug for Scan<St, S, Fut, F> where
    St: Stream + Debug,
    S: Debug,
    Fut: Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, F> Debug for SinkMapErr<Si, F> where
    Si: Debug,
    F: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Flatten<St> where
    St: Stream,
    Flatten<St, <St as Stream>::Item>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryFlatten<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for TryMaybeDone<Fut> where
    Fut: Debug + TryFuture,
    <Fut as TryFuture>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, E> Debug for OkInto<Fut, E> where
    MapOk<Fut, IntoFn<E>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, T, F> Debug for Fold<St, Fut, T, F> where
    St: Debug,
    Fut: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for IntoIter<Fut> where
    Fut: Debug + Unpin, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, U> Debug for MappedMutexGuard<'_, T, U> where
    U: Debug + ?Sized,
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Fuse<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Si, Item> Debug for Close<'a, Si, Item> where
    Si: Debug + ?Sized,
    Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for CatchUnwind<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, E> Debug for ErrInto<Fut, E> where
    MapErr<Fut, IntoFn<E>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AbortRegistration

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PollImmediate<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for InspectErr<Fut, F> where
    Inspect<IntoFuture<Fut>, InspectErrFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Take<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for Next<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for BufferUnordered<St> where
    St: Stream + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Map<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for Join5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    Fut5: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug,
    <Fut5 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for Then<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W, Item> Debug for IntoSink<W, Item> where
    W: Debug,
    Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for Select<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Shared<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, Si, St> Debug for SendAll<'_, Si, St> where
    Si: Debug + ?Sized,
    St: Debug + TryStream + ?Sized,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for TryNext<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadLine<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for WriteVectored<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AbortHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for SelectAll<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, C> Debug for Collect<St, C> where
    St: Debug,
    C: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for SeeKRelative<'a, R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TrySkipWhile<St, Fut, F> where
    St: TryStream + Debug,
    Fut: Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for MapOk<Fut, F> where
    Map<IntoFuture<Fut>, MapOkFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for FlattenStream<F> where
    F: Future,
    Flatten<F, <F as Future>::Output>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, FromA, FromB> Debug for Unzip<St, FromA, FromB> where
    St: Debug,
    FromA: Debug,
    FromB: Debug, 

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, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for RepeatWith<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for InspectOk<St, F> where
    Inspect<IntoStream<St>, InspectOkFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for IntoIter<St> where
    St: Debug + Unpin, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEachConcurrent<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for CatchUnwind<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Close<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Window<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for SelectOk<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for Then<Fut1, Fut2, F> where
    Flatten<Map<Fut1, F>, Fut2>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for InspectErr<St, F> where
    Inspect<IntoStream<St>, InspectErrFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterMut<'a, Fut> where
    Fut: Debug + Unpin, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for LineWriter<W> where
    W: Debug + AsyncWrite, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for IntoFuture<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for JoinAll<F> where
    F: Future + Debug,
    <F as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for Lazy<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for SplitStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TakeWhile<St, Fut, F> where
    St: Stream + Debug,
    Fut: Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Abortable<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repeat

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for MapErr<St, F> where
    Map<IntoStream<St>, MapErrFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    T: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for Flatten<F> where
    F: Future,
    Flatten<F, <F as Future>::Output>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, Item, U, St, F> Debug for WithFlatMap<Si, Item, U, St, F> where
    Si: Debug,
    St: Debug,
    Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2, Clos, State> Debug for SelectWithStrategy<St1, St2, Clos, State> where
    St1: Debug,
    St2: Debug,
    State: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for Read<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, T> Debug for MapInto<Fut, T> where
    Map<Fut, IntoFn<T>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for MapOk<St, F> where
    Map<IntoStream<St>, MapOkFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, Item> Debug for SplitSink<S, Item> where
    S: Debug,
    Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for Seek<'a, S> where
    S: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, W> Debug for CopyBuf<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for PollFn<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for PollFn<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadToString<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Ready<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Fuse<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for Iter<'a, Fut> where
    Fut: Debug + Unpin, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RemoteHandle<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for UnwrapOrElse<Fut, F> where
    Map<IntoFuture<Fut>, UnwrapOrElseFn<F>>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, T, F> Debug for TryFold<St, Fut, T, F> where
    St: Debug,
    Fut: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for Map<Fut, F> where
    Map<Fut, F>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Remote<Fut> where
    Fut: Future + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Lines<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadUntil<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Skip<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for Join4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for TryJoin3<Fut1, Fut2, Fut3> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadToEnd<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEach<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2> Debug for TryJoin<Fut1, Fut2> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, Si> Debug for FlattenSink<Fut, Si> where
    TryFlatten<Fut, Si>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Cycle<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for StreamFuture<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for ReadyChunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Si> Debug for Forward<St, Si> where
    St: TryStream,
    Forward<St, Si, <St as TryStream>::Ok>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Inspect<St, F> where
    Map<St, InspectFn<F>>: Debug, 

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, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryChunks<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for AndThen<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Si, Item> Debug for Flush<'a, Si, Item> where
    Si: Debug + ?Sized,
    Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for OptionFuture<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, Item> Debug for Buffer<Si, Item> where
    Si: Debug,
    Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Peekable<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryTakeWhile<St, Fut, F> where
    St: TryStream + Debug,
    Fut: Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for Join3<Fut1, Fut2, Fut3> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for MutexGuard<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for OrElse<St, Fut, F> where
    St: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, C> Debug for TryCollect<St, C> where
    St: Debug,
    C: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for Filter<St, Fut, F> where
    St: Stream + Debug,
    Fut: Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Aborted

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Flush<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinRef<'a, Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Take<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, E> Debug for TryChunksError<T, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Chunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

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, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadExact<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for TryJoinAll<F> where
    F: TryFuture + Debug,
    <F as TryFuture>::Ok: Debug,
    <F as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for TryJoin4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for FillBuf<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for IntoStream<F> where
    Once<F>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for TryFlattenStream<Fut> where
    Fut: TryFuture,
    TryFlatten<Fut, <Fut as TryFuture>::Ok>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for SelectNextSome<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2> Debug for TryFlatten<Fut1, Fut2> where
    TryFlatten<Fut1, Fut2>: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for FutureObj<'_, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for LocalFutureObj<'_, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpawnError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for WakerRef<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SendError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Canceled

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Cancellation<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Drain<'_, T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for BlockingStream<S> where
    S: Debug + Stream + Unpin, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LocalPool

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LocalSpawner

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Enter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EnterError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SignalKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendTimeoutError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DuplexStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BarrierWaitResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OwnedReadHalf

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OwnedSemaphorePermit

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stdout

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ready

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OnceCell<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Lines<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryCurrentError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReuniteError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Elapsed

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DirBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sleep

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SocketAddr

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for JoinHandle<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for OwnedRwLockMappedWriteGuard<T, U> where
    U: Debug + ?Sized,
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Barrier

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signal

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Split<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Notified<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RwLockMappedWriteGuard<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Notify

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Interval

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for MutexGuard<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixListener

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Instant

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stdin

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for JoinError

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LocalSet

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for File

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SemaphorePermit<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Take<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DirEntry

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TrySendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for MappedMutexGuard<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AcquireError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Permit<'_, T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpSocket

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RwLockReadGuard<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repeat

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ReadHalf<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OwnedRwLockWriteGuard<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for WriteHalf<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LocalKey<T> where
    T: 'static, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for AsyncFdReadyGuard<'a, T> where
    T: Debug + AsRawFd, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OwnedReadHalf

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sink

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for AsyncFd<T> where
    T: Debug + AsRawFd, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MissedTickBehavior

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReadDir

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OwnedPermit<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for WriteHalf<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RwLock<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SetError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryAcquireError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryLockError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for AsyncFdReadyMutGuard<'a, T> where
    T: Debug + AsRawFd, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<RW> Debug for BufStream<RW> where
    RW: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for OwnedRwLockReadGuard<T, U> where
    U: Debug + ?Sized,
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Semaphore

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stderr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Runtime

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OwnedWriteHalf

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OwnedMutexGuard<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for ReadBuf<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OwnedWriteHalf

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryIoError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RwLockWriteGuard<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpenOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Interest

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UCred

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UdpSocket

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Timeout<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReuniteError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixDatagram

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for EnterGuard<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Ref<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ReadHalf<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Receiver

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UdpSocket

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Interest

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Waker

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Iter<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Events

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixListener

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Poll

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sender

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Token

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnixDatagram

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Registry

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Event

When the alternate flag is enabled this will print platform specific details, for example the fields of the kevent structure on platforms that use kqueue(2). Note however that the output of this implementation is not consider a part of the stable API.

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SourceFd<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SocketAddr

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for MetadataBuilder<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for RecordBuilder<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Record<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetLoggerError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LevelFilter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for Writer<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for Reader<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Limit<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BytesMut

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Take<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Bytes

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UninitSlice

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OnceBox<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OnceCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnceNonZeroUsize

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OnceCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F> Debug for Lazy<T, F> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F> Debug for Lazy<T, F> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnceBool

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Domain

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SockAddr

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InterfaceIndexOrAddress

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Socket

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TcpKeepalive

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Protocol

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for MaybeUninitSlice<'a>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for SockRef<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SigId

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Box<dyn FilterMap<Output = Option<Uncased<'a>>> + 'static, Global>

fn fmt(&self, &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Source

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Tagged<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelativePathBuf

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Kind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Actual

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Figment

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Profile

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Metadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Box<dyn Interpolator<Output = String> + 'static, Global>

fn fmt(&self, &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for Either<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Env

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Tag

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Serialized<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for Data<F> where
    F: Debug + Format, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Num

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Span<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<C> Debug for ErrorInfo<C> where
    C: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Pear<I> where
    I: Debug + Input, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for Expected<T, S> where
    T: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Options<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<C, E> Debug for ParseError<C, E> where
    C: Debug,
    E: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Cursor<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Extent<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Text<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NotEnoughSpaceError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InlinableString

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InlineString

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s> Debug for Uncased<'s>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UncasedStr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DatetimeParseError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Datetime

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Spanned<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Map<String, Value>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ByteUnit

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WaitTimeoutResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnceState

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Once

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Condvar

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, G, T> Debug for MappedReentrantMutexGuard<'a, R, G, T> where
    R: 'a + RawMutex,
    G: 'a + GetThreadId,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockReadGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for MutexGuard<'a, R, T> where
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, T> Debug for Mutex<R, T> where
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockWriteGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for MappedMutexGuard<'a, R, T> where
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockUpgradableReadGuard<'a, R, T> where
    R: 'a + RawRwLockUpgrade,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, T> Debug for RwLock<R, T> where
    R: RawRwLock,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, G, T> Debug for ReentrantMutexGuard<'a, R, G, T> where
    R: 'a + RawMutex,
    G: 'a + GetThreadId,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockReadGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, G, T> Debug for ReentrantMutex<R, G, T> where
    R: RawMutex,
    G: GetThreadId,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockWriteGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, S> Debug for ScopeGuard<T, F, S> where
    T: Debug,
    F: FnOnce(T),
    S: Strategy, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Always

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RequeueOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnparkResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParkToken

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnparkToken

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FilterOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParkResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CollectionAllocErr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Array,
    <T as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Storage<T> where
    T: Debug + Send + Sync, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K> Debug for Container<K> where
    K: Kind, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Atomic<T> where
    T: Copy + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Instant

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Time

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Duration

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ComponentRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OffsetDateTime

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Weekday

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sign

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Format

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Date

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Format

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndeterminateOffset

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PrimitiveDateTime

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ConversionRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UtcOffset

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReceiverStream<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Empty<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Once<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IntervalStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SignalStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedReceiverStream<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Iter<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for StreamMap<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoValues<K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Difference<'_, T, S> where
    T: Debug + Eq + Hash,
    S: BuildHasher, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    T: Debug + Eq + Hash,
    S: BuildHasher, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Union<'_, T, S> where
    T: Debug + Eq + Hash,
    S: BuildHasher, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for OccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S1, S2> Debug for SymmetricDifference<'_, T, S1, S2> where
    T: Debug + Eq + Hash,
    S1: BuildHasher,
    S2: BuildHasher, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoKeys<K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Entry<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for IndexSet<T, S> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S> Debug for IndexMap<K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Drain<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S, A> Debug for Union<'_, T, S, A> where
    T: Debug + Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S, A> Debug for Intersection<'_, T, S, A> where
    T: Debug + Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for RawEntryBuilder<'_, K, V, S, A> where
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, A> Debug for Drain<'_, K, V, A> where
    K: Debug,
    V: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S, A> Debug for Difference<'_, T, S, A> where
    T: Debug + Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for RawOccupiedEntryMut<'_, K, V, S, A> where
    K: Debug,
    V: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, A> Debug for IntoIter<K, A> where
    K: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S, A> Debug for HashSet<T, S, A> where
    T: Eq + Hash + Debug,
    S: BuildHasher,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for OccupiedError<'_, K, V, S, A> where
    K: Debug,
    V: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, A> Debug for Drain<'_, K, A> where
    K: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S, A> Debug for HashMap<K, V, S, A> where
    K: Debug,
    V: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for RawEntryBuilderMut<'_, K, V, S, A> where
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for VacantEntry<'_, K, V, S, A> where
    K: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for RawEntryMut<'_, K, V, S, A> where
    K: Debug,
    V: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S, A> Debug for SymmetricDifference<'_, T, S, A> where
    T: Debug + Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for RawVacantEntryMut<'_, K, V, S, A> where
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryReserveError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for Entry<'_, K, V, S, A> where
    K: Debug,
    V: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S, A> Debug for OccupiedEntry<'_, K, V, S, A> where
    K: Debug,
    V: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, A> Debug for IntoIter<K, V, A> where
    K: Debug,
    V: Debug,
    A: Allocator + Clone, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for Multipart<'r>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for Field<'r>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SizeLimit

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Constraints

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Values<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HeaderName

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for OccupiedEntry<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for GetAll<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Port<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ValueIter<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidStatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Extensions

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidMethod

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Keys<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Response<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Scheme

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PathAndQuery

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HeaderValue

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ValuesMut<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidHeaderName

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parts

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parts

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidHeaderValue

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Entry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidUri

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Method

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ValueDrain<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidUriParts

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ValueIterMut<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parts

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Authority

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ToStrError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Uri

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Request<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for HeaderMap<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CoderResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Encoding

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Latin1Bidi

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EncoderResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecoderResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, R> Debug for Mutex<T, R> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, R> Debug for SpinMutex<T, R> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for SpinMutexGuard<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for MutexGuard<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'headers, 'buf> Debug for Response<'headers, 'buf> where
    'buf: 'headers, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Header<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Status<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'headers, 'buf> Debug for Request<'headers, 'buf> where
    'buf: 'headers, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidChunkSize

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for FramedWrite<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ReaderStream<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, B> Debug for StreamReader<S, B> where
    S: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LengthDelimitedCodecError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, D> Debug for FramedRead<T, D> where
    T: Debug,
    D: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LengthDelimitedCodec

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnyDelimiterCodec

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CancellationToken

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PollSender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LinesCodec

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReusableBoxFuture<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for FramedParts<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for Framed<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<L, R> Debug for Either<L, R> where
    L: Debug,
    R: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PollSemaphore

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnyDelimiterCodecError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LinesCodecError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for WaitForCancellationFuture<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DropGuard

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BytesCodec

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromStrError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Params<'a>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Mime

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Name<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RawStrBuf

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentType

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryFromUriError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Error<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Accept

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PathError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Path<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Query<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StatusClass

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Path

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for Segments<'a, P> where
    P: Debug + Part,
    <P as Part>::Raw: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Reference<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Uri<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'h> Debug for Header<'h>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MediaType

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'h> Debug for HeaderMap<'h>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Method

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Asterisk

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Absolute<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for QMediaType

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Origin<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Authority<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Query

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AddrIncoming

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, S> Debug for Server<I, S, Exec> where
    I: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Upgraded

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, E> Debug for Builder<I, E> where
    I: Debug,
    E: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F, E> Debug for Connecting<I, F, E> where
    I: Debug,
    F: Debug,
    E: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, S> Debug for Connection<I, S, Exec> where
    S: HttpService<Body>, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Parts<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Body

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Protocol

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Http<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AddrStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for Parts<T, S> where
    T: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sender

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnUpgrade

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpDate

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D, E> Debug for UnsyncBoxBody<D, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Trailers<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D, E> Debug for BoxBody<D, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Data<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Empty<D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SizeHint

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B, F> Debug for MapData<B, F> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Full<D> where
    D: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B, F> Debug for MapErr<B, F> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Entered<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for WithDispatch<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Span

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EnteredSpan

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Instrumented<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Attributes<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Event<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Kind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Record<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugValue<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ValueSet<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for dyn Value + 'static

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Current

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Iter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FieldSet

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LevelFilter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Dispatch

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelFilterError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NoSubscriber

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Identifier

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Field

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DisplayValue<T> where
    T: Display, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DefaultGuard

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Interest

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Id

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetGlobalDefaultError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B> where
    T: AsyncRead + AsyncWrite + Debug,
    B: Debug + Buf, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for ReadySendRequest<B> where
    B: Debug + Buf, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PushPromise

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecvStream

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PingPong

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendStream<B> where
    B: Debug + Buf, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Protocol

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ping

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PushPromises

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendPushedResponse<B> where
    B: Buf + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PushedResponseFuture

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StreamId

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    T: Debug,
    B: Debug + Buf, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FlowControl

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendRequest<B> where
    B: Buf, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    T: AsyncRead + AsyncWrite + Debug,
    B: Debug + Buf, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for SendResponse<B> where
    B: Debug + Buf, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ResponseFuture

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pong

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Reason

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for SplitInternal<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for MatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SearchStep

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for SplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for RSplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for MatchesInternal<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for RSplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for CharSearcher<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for Matches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for RMatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for SplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for RSplit<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, F> Debug for CharPredicateSearcher<'_, F> where
    F: FnMut(char) -> bool, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for MatchIndicesInternal<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b> Debug for StrSearcher<'a, 'b>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for RMatches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for SplitNInternal<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for Split<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SameSite

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CookieJar

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c> Debug for CookieBuilder<'c>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Expiration

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c> Debug for Cookie<'c>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PersistError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TempPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TempDir

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PathPersistError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NamedTempFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpooledTempFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b> Debug for Builder<'a, 'b>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Rng

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Implementors

impl Debug for validators::models::Host

impl Debug for validators::models::Protocol

impl Debug for Base32DecodedError

impl Debug for Base32Error

impl Debug for Base64DecodedError

impl Debug for Base64Error

impl Debug for Base64UrlDecodedError

impl Debug for Base64UrlError

impl Debug for DomainError

impl Debug for EmailError

impl Debug for HostError

impl Debug for HttpFtpURLError

impl Debug for HttpURLError

impl Debug for IPError

impl Debug for IPv4Error

impl Debug for IPv6Error

impl Debug for IpAddr

impl Debug for JSONError

impl Debug for LengthError

impl Debug for LineError

impl Debug for MacAddressError

impl Debug for NumberError

impl Debug for PhoneError

impl Debug for SignedIntegerError

impl Debug for TextError

impl Debug for UUIDError

impl Debug for UnsignedIntegerError

impl Debug for ValidatorCaseOption

impl Debug for ValidatorOption

impl Debug for ValidatorSeparatorOption

impl Debug for Alignment

impl Debug for BooleanError

impl Debug for Ipv4Addr

impl Debug for Ipv6Addr

impl Debug for RawStr

impl Debug for RegexError

impl Debug for SemVerError

impl Debug for validators::prelude::validators_prelude::Status

impl Debug for String

impl Debug for URLError

impl Debug for validators::prelude::validators_prelude::fmt::Error

impl<'_> Debug for Arguments<'_>

impl<'_, B> Debug for Cow<'_, B> where
    B: Debug + ToOwned + ?Sized,
    <B as ToOwned>::Owned: Debug, 

impl<'r> Debug for ValueField<'r>

impl<'v> Debug for validators::prelude::validators_prelude::FormError<'v>

impl<T> Debug for ValidatorRangeOption<T> where
    T: Debug, 

impl<T, A> Debug for Vec<T, A> where
    T: Debug,
    A: Allocator, 

impl<T: Debug, E: Debug, D: Debug> Debug for validators::prelude::validators_prelude::Result<T, E, D>