Trait validators::prelude::validators_prelude::fmt::Debug

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

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Stability

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

Examples

Deriving an implementation:

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

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

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

Manually implementing:

use std::fmt;

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

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

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

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

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

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

Pretty-printing with #?:

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

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

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

Required methods

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

Formats the value using the given formatter.

Examples

use std::fmt;

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

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

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

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

Loading content...

Trait Implementations

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

impl Trait for dyn Debug + 'static + Sync

impl Trait for dyn Debug + 'static + Send

Implementations on Foreign Types

impl Debug for SocketAddrV6

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

impl Debug for System

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

impl Debug for File

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

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

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

impl Debug for AccessError

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

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

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

impl Debug for Output

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

impl Debug for ExitCode

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

impl Debug for DirBuilder

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Stderr

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

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

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

impl Debug for SocketAddr

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

impl Debug for Error

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

impl Debug for ThreadId

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

impl<T> Debug for SyncSender<T>

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

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

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

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

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

impl Debug for Permissions

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

impl Debug for CString

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

impl Debug for OpenOptions

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

impl Debug for Stdout

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

impl Debug for BacktraceFrame

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

impl Debug for TcpListener

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

impl Debug for TcpStream

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

impl Debug for NulError

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

impl Debug for OsStr

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

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

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

impl Debug for VarError

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

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

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

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

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

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

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

impl Debug for IntoStringError

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

impl Debug for UnixStream

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

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

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

impl Debug for AddrParseError

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

impl Debug for VarsOs

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

impl Debug for UdpSocket

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

impl Debug for Child

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

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

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

impl Debug for UnixListener

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

impl Debug for Stdin

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

impl Debug for SystemTime

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

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

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

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

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

impl Debug for Empty

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

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

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

impl<T> Debug for PoisonError<T>

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

impl Debug for ChildStdout

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

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

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

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

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

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

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

impl Debug for Condvar

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

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

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

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

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

impl Debug for ErrorKind

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

impl<T> Debug for Sender<T>

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

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

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

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

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

impl Debug for RecvTimeoutError

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

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

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

impl Debug for Repeat

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

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

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

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

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

impl Debug for ReadDir

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

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

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

impl<T> Debug for Key<T>

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

impl Debug for OsString

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

impl Debug for BacktraceStatus

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

impl Debug for Instant

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

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

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

impl Debug for Metadata

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

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

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

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

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

impl Debug for Path

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

impl<T> Debug for Key<T>

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

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

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

impl Debug for Command

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

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

impl Debug for FromVecWithNulError

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

impl Debug for SocketAddr

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

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

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

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

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

impl Debug for RecvError

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

impl Debug for UnixDatagram

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

impl Debug for Barrier

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

impl Debug for Vars

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

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

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

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

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

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

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

impl Debug for DefaultHasher

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

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

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

impl Debug for ExitStatus

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

impl Debug for ChildStderr

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

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

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

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

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

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

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

impl Debug for ChildStdin

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

impl Debug for ArgsOs

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

impl Debug for Shutdown

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

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

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

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

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

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

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

impl Debug for Ipv6MulticastScope

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

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

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

impl<T> Debug for SendError<T>

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

impl<T> Debug for TrySendError<T>

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

impl Debug for SystemTimeError

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

impl Debug for TryRecvError

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

impl Debug for BarrierWaitResult

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

impl Debug for UCred

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

impl Debug for DirEntry

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

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

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

impl Debug for RandomState

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

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

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

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

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

impl Debug for Once

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

impl Debug for WaitTimeoutResult

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

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

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

impl Debug for Builder

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

impl<T> Debug for JoinHandle<T>

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

impl Debug for Sink

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

impl Debug for OnceState

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

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

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

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

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

impl Debug for JoinPathsError

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

impl Debug for FileType

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

impl Debug for Stdio

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

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

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

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

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

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

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

impl Debug for PathBuf

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

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

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

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

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

impl Debug for SocketAddrV4

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

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

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

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

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

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

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

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

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

impl Debug for Args

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

impl Debug for Initializer

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

impl Debug for CStr

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

impl Debug for StripPrefixError

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

impl Debug for Thread

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

impl Debug for Backtrace

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

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

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

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

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

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

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

impl Debug for FromBytesWithNulError

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

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

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

impl<T> Debug for TryLockError<T>

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

impl<T> Debug for Receiver<T>

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

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

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

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

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

impl Debug for SeekFrom

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

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

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

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

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

impl Debug for AtomicU64

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

impl Debug for AtomicI16

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for __m256d

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

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

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

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

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

impl Debug for EscapeDefault

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

impl Debug for Waker

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

impl Debug for __m128

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

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

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

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

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

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

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

impl Debug for __m512

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

impl Debug for NonZeroI32

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

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

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

impl<T> Debug for Pending<T>

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

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

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

impl Debug for AtomicIsize

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

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

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

impl Debug for Layout

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

impl Debug for ()

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

impl Debug for BorrowError

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

impl Debug for __m512i

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

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

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

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

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

impl Debug for BorrowMutError

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

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

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

impl Debug for CharTryFromError

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

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

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

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

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

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

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

impl Debug for NoneError

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

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

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

impl Debug for ParseFloatError

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

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

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

impl Debug for LayoutError

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

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

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

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

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

impl Debug for EscapeUnicode

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

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

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

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

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

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

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

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

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

impl Debug for AtomicBool

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

impl Debug for Ordering

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

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

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

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

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

impl Debug for NonZeroUsize

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

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

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

impl Debug for Utf8Lossy

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

impl Debug for dyn Any + 'static + Send

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

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

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

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

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

impl Debug for __m128d

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for CpuidResult

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

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

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

impl Debug for u16

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

impl Debug for AtomicUsize

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

impl Debug for SipHasher

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

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

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

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

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

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

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

impl Debug for SearchStep

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

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

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

impl Debug for __m512d

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

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

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

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

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

impl Debug for Duration

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

impl Debug for c_void

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroU64

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

impl Debug for PhantomPinned

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

impl Debug for NonZeroIsize

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

impl Debug for i16

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

impl Debug for dyn Any + 'static

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

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

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

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

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

impl Debug for NonZeroU32

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

impl Debug for i128

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

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

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

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

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

impl Debug for u8

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

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

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

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

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

impl Debug for ToUppercase

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TryFromSliceError

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

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

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

impl Debug for AtomicI64

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

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

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

impl Debug for NonZeroU8

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

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

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

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

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

impl Debug for u64

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TryFromIntError

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

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

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

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

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

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

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

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

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

impl<T> Debug for MaybeUninit<T>

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

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

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

impl Debug for NonZeroU16

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

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

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

impl Debug for NonZeroI16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for DecodeUtf16Error

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

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

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

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

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

impl Debug for f64

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

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

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

impl Debug for __m128bh

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

impl Debug for IntErrorKind

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

impl Debug for AtomicU8

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

impl Debug for AtomicU32

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

impl Debug for ParseBoolError

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

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

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

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

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

impl Debug for bool

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

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

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

impl Debug for __m256i

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroI8

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

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

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

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

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

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

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

impl Debug for __m256

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

impl Debug for Infallible

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

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

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

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

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

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

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

impl Debug for usize

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

impl Debug for __m128i

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

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

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

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

impl Debug for i32

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

impl Debug for !

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

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

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

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

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

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

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

impl Debug for RangeFull

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

impl Debug for Utf8Error

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

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

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

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

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

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

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

impl Debug for __m512bh

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

impl<T> Debug for Discriminant<T>

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

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

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

impl Debug for AtomicI8

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

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

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

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

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

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

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

impl Debug for char

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

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

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

impl<F> Debug for FromFn<F>

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

impl Debug for __m256bh

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TypeId

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroI128

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

impl Debug for u32

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

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

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

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

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

impl Debug for AllocError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for RawWakerVTable

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

impl Debug for EscapeDefault

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

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

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

impl Debug for NonZeroU128

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

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

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

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

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

impl Debug for NonZeroI64

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

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

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

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

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

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

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

impl Debug for Ordering

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<H> Debug for BuildHasherDefault<H>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for EscapeDebug

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

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

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

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

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

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

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

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

impl<F> Debug for PollFn<F>

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

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

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

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

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

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

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

impl Debug for AtomicU128

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

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicU16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicI32

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

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

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

impl Debug for ParseCharError

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

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

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

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

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

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

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

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

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

impl<T> Debug for AtomicPtr<T>

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

impl Debug for AtomicI128

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

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

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

impl<T> Debug for Empty<T>

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

impl Debug for i64

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

impl Debug for f32

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

impl Debug for i8

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

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

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

impl Debug for ParseIntError

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

impl Debug for ToLowercase

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for str

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for RawWaker

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

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

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

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

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

impl Debug for FpCategory

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

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

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

impl Debug for isize

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

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

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

impl Debug for u128

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

impl Debug for Global

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TryReserveError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for IntoIter<T, A> where
    T: Debug,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Drain<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for OccupiedEntry<'_, K, V> where
    V: Debug,
    K: Debug + Ord, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Cursor<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Debug + Ord, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Entry<'_, K, V> where
    V: Debug,
    K: Debug + Ord, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, F> Debug for DrainFilter<'_, K, V, F> where
    V: Debug,
    K: Debug,
    F: FnMut(&K, &mut V) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromUtf16Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Drain<'_>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for SymmetricDifference<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoValues<K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, A> Debug for Drain<'_, T, A> where
    T: Debug,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for DrainSorted<'a, T> where
    T: Debug + Ord, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for OccupiedError<'_, K, V> where
    V: Debug,
    K: Debug + Ord, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, F> Debug for DrainFilter<'_, T, F> where
    T: Debug,
    F: FnMut(&mut T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, F, A> Debug for DrainFilter<'a, T, F, A> where
    T: Debug,
    A: Debug + Allocator,
    F: Debug + FnMut(&mut T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I, A> Debug for Splice<'a, I, A> where
    A: 'a + Debug + Allocator,
    I: 'a + Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Rc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromUtf8Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Range<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for PeekMut<'_, T> where
    T: Ord + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for CursorMut<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Range<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LinkedList<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoKeys<K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIterSorted<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for BTreeMap<K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for Box<T, A> where
    T: Debug + ?Sized,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for VecDeque<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, K, V> Debug for IterMut<'a, K, V> where
    V: 'a + Debug,
    K: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for BTreeSet<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Intersection<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Union<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for RangeMut<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for _Unwind_Reason_Code

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpecificationError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodeError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Wrap

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BitOrder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodeKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Encoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodePartial

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Specification

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Translate

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Errors

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'text> Debug for BidiInfo<'text>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BidiClass

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Level

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'text> Debug for InitialInfo<'text>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParagraphInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IsNormalized

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for TinyVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s, T> Debug for SliceVec<'s, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for TinyVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryFromSliceError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Map<String, Value>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Number

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompactFormatter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Category

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for BytesDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IgnoredAny

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    I: Debug, 

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I128Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U128Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Defaults

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Metadata

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Format

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Id

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parse

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'n, 'd, 'f> Debug for Formatter<'n, 'd, 'f>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Validation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Database

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Source

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Descriptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Descriptors

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PhoneNumber

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Format

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Metadata

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Mode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Type

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Carrier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Metadata

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Extension

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NationalNumber

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Code

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Descriptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for VerboseError<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VerboseErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Err<E> where
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Needed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Endianness

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompareResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorCode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CapacityError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatchesIntoIter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Matches<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c, 't> Debug for SubCaptureMatches<'c, 't> where
    't: 'c, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for CaptureMatches<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSetBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Regex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Shows the original regular expression.

impl<'r, 't> Debug for Matches<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Match<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SetMatchesIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for CaptureNames<'r>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatches

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureLocations

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for CaptureMatches<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatchesIntoIter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SetMatchesIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Regex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Shows the original regular expression.

impl Debug for RegexSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for SplitN<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for SplitN<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Split<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSetBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureLocations

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Match<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c, 't> Debug for SubCaptureMatches<'c, 't> where
    't: 'c, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for NoExpand<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatches

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for CaptureNames<'r>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for NoExpand<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Split<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s, 'h> Debug for FindIter<'s, 'h>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindIter<'a, 'b, S> where
    S: 'a + Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MatchKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for AhoCorasick<S> where
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AhoCorasickBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Match

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MatchKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, S> Debug for StreamFindIter<'a, R, S> where
    S: 'a + Debug + StateID,
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Searcher

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindOverlappingIter<'a, 'b, S> where
    S: 'a + Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassAsciiKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Group

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Concat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Range

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Printer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HirKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetBinaryOpKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ast

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBracketed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionOp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Sequence

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parser

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literals

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FlagsItemKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repetition

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Anchor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetItem

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HexLiteralKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Span

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ClassBytesIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaseFoldError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeOpKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GroupKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnicodeWordError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Hir

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Position

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Alternation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Assertion

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassAscii

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FlagsItem

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LiteralKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WordBoundary

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpecialLiteralKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Group

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parser

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetUnion

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Flag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ClassUnicodeIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Class

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetBinaryOp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WithComments

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Translator

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBytesRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Printer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AssertionKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Flags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Comment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repetition

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Sequences

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureName

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Class

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TranslatorBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassPerlKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBytes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GroupKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassPerl

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LazyRegex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LazyRegexBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CachedRegexBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexCache

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CachedRegex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S> Debug for LruCache<K, V, S> where
    S: BuildHasher,
    V: Debug,
    K: Debug + Eq + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B, S> Debug for LinkedHashMap<A, B, S> where
    S: BuildHasher,
    A: Debug + Hash + Eq,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Returns a string that lists the key-value pairs in insertion order.

impl<'a> Debug for BytesText<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for BytesStart<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Event<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Attribute<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for BytesEnd<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for BytesDecl<'a>

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I, E> Debug for ProcessResults<'a, I, E> where
    E: 'a + Debug,
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Position<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Intersperse<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Tee<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I> Debug for Format<'a, I> where
    I: Iterator,
    <I as Iterator>::Item: Debug, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Permutations<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for ConsTuples<I, J> where
    I: Debug + Iterator<Item = J>,
    J: Debug, 

pub 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, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I, F> Debug for TakeWhileRef<'a, I, F> where
    I: Iterator + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for MultiPeek<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for Interleave<I, J> where
    I: Debug,
    J: Debug, 

pub 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, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TupleBuffer<T> where
    T: Debug + HomogeneousTuple,
    <T as TupleCollect>::Buffer: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Step<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for EitherOrBoth<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for ExactlyOneError<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for RcIter<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Combinations<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for ZipEq<I, J> where
    I: Debug,
    J: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Zip<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, V, F> Debug for UniqueBy<I, V, F> where
    V: Debug + Hash + Eq,
    I: Iterator + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for MinMaxResult<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for RepeatCall<F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Iterate<St, F> where
    St: Debug, 

pub 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>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for PutBack<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, T> Debug for TupleCombinations<I, T> where
    T: Debug + HasCombination<I>,
    I: Debug + Iterator,
    <T as HasCombination<I>>::Combination: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for ZipLongest<T, U> where
    T: Debug,
    U: Debug, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for Batching<I, F> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, T> Debug for TupleWindows<I, T> where
    T: Debug + HomogeneousTuple,
    I: Debug + Iterator<Item = <T as TupleCollect>::Item>, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for FoldWhile<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for WhileSome<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for PutBackN<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for RepeatN<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Unfold<St, F> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<L, R> Debug for Either<L, R> where
    R: Debug,
    L: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Identifier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SemVerError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VersionReq

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Version

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReqParseError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Identifier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Compat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Comparator

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'input> Debug for Lexer<'input>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Version

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Identifier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Op

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Range

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'input> Debug for Token<'input>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'input> Debug for Error<'input>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RangeSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for Pairs<'i, R> where
    R: RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for Pair<'i, R> where
    R: RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for Token<'i, R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LineColLocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ErrorVariant<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Operator<R> where
    R: Debug + RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Lookahead

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for Tokens<'i, R> where
    R: RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PrecClimber<R> where
    R: Debug + RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i> Debug for Span<'i>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Error<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for ParserState<'i, R> where
    R: Debug + RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i> Debug for Position<'i>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Atomicity

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Assoc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MatchDir

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InputLocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'i, R> Debug for FlatPairs<'i, R> where
    R: RuleType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TrieSetOwned

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for TrieSetSlice<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PathSegmentsMut<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for UrlQuery<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Position

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Origin

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Url

Debug the serialization of this URL.

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SyntaxViolation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpaqueOrigin

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Host<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ByteSerialize<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PercentDecode<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Ascii<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for UniCase<S> where
    S: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LaunchErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Accepted<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c> Debug for LocalResponse<'c>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LoggingLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c> Debug for LocalRequest<'c>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'f, E> Debug for FormDataError<'f, E> where
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NoContent

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RouteUriError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for Request<'r>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Html<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BadRequest<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Stream<T> where
    T: Read + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'q> Debug for Query<'q>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Route

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Flash<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Json<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ConfigError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, T> Debug for State<'r, T> where
    T: 'static + Debug + Send + Sync, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Custom<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Created<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LaunchError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Content<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Debug<E> where
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for NotFound<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, E, F> Debug for Outcome<S, E, F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Limits

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Body<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Css<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Redirect

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'f> Debug for FormItems<'f>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'f> Debug for FormParseError<'f>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for JavaScript<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NamedFile

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LenientForm<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for Response<'r>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'f> Debug for FormItem<'f>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Plain<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Unauthorized<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Environment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Xml<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for MsgPack<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Form<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Forbidden<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Kind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Conflict<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StatusClass

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Cookies<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s> Debug for Uncased<'s>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Origin<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SegmentError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UncasedStr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Absolute<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Method

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Uri<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Query

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Authority<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'h> Debug for Header<'h>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for QMediaType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Path

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'h> Debug for HeaderMap<'h>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Error<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Segments<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Accept

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MediaType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Position<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for ParseErr<I> where
    I: Debug + Input,
    <I as Input>::Token: Debug,
    <I as Input>::InSlice: Debug,
    <I as Input>::Slice: Debug,
    <I as Input>::Context: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Text<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, I, S> Debug for Expected<T, I, S> where
    S: Debug,
    T: Debug,
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s> Debug for StringFile<'s>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for USERINFO_ENCODE_SET

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for QUERY_ENCODE_SET

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for PercentEncode<'a, E> where
    E: Debug + EncodeSet, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PATH_SEGMENT_ENCODE_SET

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SIMPLE_ENCODE_SET

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PercentDecode<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DEFAULT_ENCODE_SET

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CollectionAllocErr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c> Debug for Cookie<'c>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SameSite

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CookieJar

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CookieBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for TmFmt<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Duration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Tm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SteadyTime

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OutOfRangeError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Timespec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for WeightedIndex<X> where
    X: Debug + SampleUniform + PartialOrd<X>,
    <X as SampleUniform>::Sampler: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UniformChar

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for IndexVecIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UniformDuration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Open01

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexVecIntoIter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StdRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for UniformInt<X> where
    X: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Standard

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for WeightedIndex<W> where
    W: Debug + Weight, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D, R, T> Debug for DistIter<D, R, T> where
    T: Debug,
    R: Debug,
    D: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpenClosed01

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ThreadRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BernoulliError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for Uniform<X> where
    X: Debug + SampleUniform,
    <X as SampleUniform>::Sampler: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WeightedError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Alphanumeric

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexVec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S, T> Debug for SliceChooseIter<'a, S, T> where
    S: 'a + Debug + ?Sized,
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ReadRng<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReadError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Bernoulli

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for UniformFloat<X> where
    X: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StepRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OsRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BlockRng<R> where
    R: BlockRngCore + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BlockRng64<R> where
    R: BlockRngCore + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha8Core

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha20Core

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha12Core

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha12Rng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha8Rng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha20Rng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CharacterSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for EncoderWriter<W> where
    W: Write, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodeError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for DecoderReader<'a, R> where
    R: Read, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, N> Debug for GenericArrayIter<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, N> Debug for GenericArray<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Greater

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for B1

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UTerm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U> Debug for NInt<U> where
    U: Debug + Unsigned + NonZero, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for B0

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Less

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U, B> Debug for UInt<U, B> where
    B: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ATerm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U> Debug for PInt<U> where
    U: Debug + Unsigned + NonZero, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Z0

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<V, A> Debug for TArr<V, A> where
    V: Debug,
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Equal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OverflowError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LoopError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidKeyLength

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidKeyNonceLength

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Aes256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Aes128

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Aes192

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<C> Debug for Ctr128<C> where
    C: BlockCipher<BlockSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>> + Debug,
    <C as BlockCipher>::ParBlocks: ArrayLength<GenericArray<u8, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GHash

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Polyval

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CtOption<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Choice

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512Trunc224

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha384

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha224

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512Trunc256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidOutputSize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Hmac<D> where
    D: Update + BlockInput + FixedOutput + Reset + Default + Clone + Debug,
    <D as BlockInput>::BlockSize: ArrayLength<u8>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MacError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidKeyLength

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidPrkLength

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidLength

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S1, S2> Debug for SymmetricDifference<'_, T, S1, S2> where
    T: Debug + Eq + Hash,
    S1: BuildHasher,
    S2: BuildHasher, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for OccupiedEntry<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S> Debug for IndexMap<K, V, S> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for IndexSet<T, S> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Entry<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S> Debug for HashMap<K, V, S> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawOccupiedEntryMut<'_, K, V, S> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for VacantEntry<'_, K, V, S> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for OccupiedEntry<'_, K, V, S> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Drain<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawVacantEntryMut<'_, K, V, S>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for Entry<'_, K, V, S> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K> Debug for IntoIter<K> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    V: Debug,
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilder<'_, K, V, S>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K> Debug for Drain<'_, K> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryReserveError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Storage<T> where
    T: 'static + Debug + Send + Sync, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ResponseHead

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for HttpWriter<W> where
    W: Write, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Expect

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IfUnmodifiedSince

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Quality

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Referer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpConnector

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Box<dyn NetworkStream + 'static + Send, Global>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DispositionParam

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Allow

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AcceptLanguage

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccessControlRequestMethod

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReferrerPolicy

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccessControlAllowOrigin

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for From

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IfModifiedSince

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Charset

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StatusClass

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LinkValue

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CacheDirective

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UserAgent

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Client

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ETag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EntityTag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RedirectPolicy

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Response<'a, W> where
    W: Debug + Any, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccessControlExposeHeaders

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Connection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AcceptRanges

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Protocol

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RangeUnit

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Cookie

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for EndError<W> where
    W: Debug + Write, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for HttpReader<R>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpDate

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Method

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExtendedValue

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Authorization<S> where
    S: Debug + Scheme, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccessControlAllowCredentials

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentRangeSpec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AcceptEncoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StrictTransportSecurity

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for PooledStream<S> where
    S: Debug + 'static, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Host

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Preference

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Encoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ProtocolName

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PreferenceApplied

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Origin

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AcceptCharset

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IfRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Expires

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Range

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentDisposition

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentLanguage

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Response

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Upgrade

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Bearer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentEncoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetCookie

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Date

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IfNoneMatch

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Server

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpVersion

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IfMatch

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccessControlMaxAge

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Link

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpStream

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccessControlAllowMethods

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelationType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MediaDesc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RawStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccessControlAllowHeaders

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, H> Debug for HeaderFormatter<'a, H> where
    H: HeaderFormat, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StatusCode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RequestUri

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Location

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, C> Debug for HttpsConnector<S, C> where
    C: Debug + NetworkConnector,
    S: Debug + SslClient<HttpStream>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Prefer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccessControlRequestHeaders

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ByteRangeSpec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TransferEncoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ConnectionOption

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Http11Message

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Listening

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ContentLength

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Incoming<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RequestHead

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DispositionType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pragma

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for HttpsStream<S> where
    S: Debug + NetworkStream, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Vary

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for QualityItem<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Accept

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Headers

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LastModified

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<L> Debug for Server<L> where
    L: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for HeaderView<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Basic

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CacheControl

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CharacterSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DisplayError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LineWrap

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LineEnding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodeError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LittleEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SyntaxViolation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ParseOptions<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Position

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Origin

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for HostAndPort<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ByteSerialize<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SocketAddrs

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for UrlQuery<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpaqueOrigin

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ParseIntoOwned<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PathSegmentsMut<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Parse<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Url

Debug the serialization of this URL.

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Host<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Serializer<T> where
    T: Debug + Target, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Errors

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for UniCase<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Status<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'headers, 'buf> Debug for Response<'headers, 'buf> where
    'buf: 'headers, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Header<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidChunkSize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserConfig

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'headers, 'buf> Debug for Request<'headers, 'buf> where
    'buf: 'headers, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LanguageTag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TopLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Mime<T> where
    T: Debug + AsRef<[(Attr, Value)]>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SubLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Attr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetLoggerError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LogLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LogLocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ShutdownLoggerError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LogLevelFilter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MaxLogLevelFilter

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for MetadataBuilder<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Record<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for RecordBuilder<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LevelFilter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetLoggerError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Level

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Paint<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Style

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Color

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Datetime

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DatetimeParseError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Spanned<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for DecoderReader<'a, R> where
    R: Read, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for EncoderWriter<'a, W> where
    W: Write, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CharacterSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DecodeError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Stream

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Loading content...

Implementors

impl Debug for validators::models::Host

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for validators::models::Protocol

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Base32DecodedError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Base32Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Base64DecodedError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Base64Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Base64UrlDecodedError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Base64UrlError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for DomainError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for EmailError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for HostError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for HttpFtpURLError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for HttpURLError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for IPError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for IPv4Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for IPv6Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for IpAddr

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for JSONError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for LengthError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for LineError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for MacAddressError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for NumberError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for PhoneError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for SignedIntegerError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for TextError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for UUIDError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for UnsignedIntegerError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for ValidatorCaseOption

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValidatorOption

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValidatorSeparatorOption

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Alignment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BooleanError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Ipv4Addr

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ipv6Addr

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RawStr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for validators::prelude::validators_prelude::SemVerError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for SemVerReqError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for validators::prelude::validators_prelude::Status

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for String

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for URLError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for validators::prelude::validators_prelude::fmt::Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_> Debug for Arguments<'_>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, B> Debug for Cow<'_, B> where
    B: Debug + ToOwned + ?Sized,
    <B as ToOwned>::Owned: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ValidatorRangeOption<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for Vec<T, A> where
    T: Debug,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Loading content...