Trait sn0int::fmt::Debug

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

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Examples

Deriving an implementation:

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

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

println!("The origin is: {:?}", origin);

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 {
        write!(f, "Point {{ x: {}, y: {} }}", self.x, self.y)
    }
}

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

println!("The origin is: {:?}", origin);

This outputs:

The origin is: Point { x: 0, y: 0 }

There are a number of debug_* methods on Formatter 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 };

println!("The origin is: {:#?}", origin);

This outputs:

The origin is: Point {
    x: 0,
    y: 0
}

Required methods

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

Formats the value using the given formatter.

Examples

use std::fmt;

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

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

assert_eq!("(1.987, 2.983)".to_owned(),
           format!("{:?}", Position { longitude: 1.987, latitude: 2.983, }));

Loading content...

Implementations on Foreign Types

impl Debug for NulError

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

impl Debug for JoinPathsError

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

impl Debug for Condvar

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

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

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

impl<T> Debug for PoisonError<T>

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

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

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

impl Debug for TcpListener

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

impl Debug for Instant

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

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

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

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

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

impl Debug for Child

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

impl Debug for ChildStderr

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

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

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

impl Debug for FromBytesWithNulError

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

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

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

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

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

impl Debug for PathBuf

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

impl<T> Debug for Sender<T>

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

impl Debug for Backtrace

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

impl Debug for Sink

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

impl Debug for CString

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

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

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

impl Debug for Vars

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

impl Debug for OpenOptions

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

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

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

impl Debug for ErrorKind

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

impl Debug for ChildStdout

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

impl Debug for ChildStdin

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

impl Debug for DefaultHasher

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

impl Debug for BarrierWaitResult

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

impl Debug for RecvError

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

impl<T> Debug for SyncSender<T>

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

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

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

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

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

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

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

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

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

impl<T> Debug for TryLockError<T>

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

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

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

impl Debug for Initializer

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

impl Debug for Ipv6Addr

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

impl Debug for Barrier

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

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

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

impl Debug for Once

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

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

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

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

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

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

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

impl Debug for Stdout

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

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

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

impl Debug for SocketAddrV4

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

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

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

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

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

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

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

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

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

impl Debug for Empty

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

impl<T> Debug for Key<T>

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

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

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

impl<T> Debug for JoinHandle<T>

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

impl Debug for Thread

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

impl Debug for Repeat

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

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

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

impl Debug for RandomState

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

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

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

impl Debug for Builder

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

impl Debug for DirBuilder

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

impl Debug for OsStr

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

impl<T> Debug for SendError<T>

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

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

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

impl<T> Debug for Receiver<T>

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

impl Debug for UnixDatagram

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

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

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

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

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

impl Debug for TryRecvError

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

impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Eq + Hash + Debug,
    S: BuildHasher,
    V: Debug, 

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

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

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

impl Debug for Metadata

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

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

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

impl Debug for SystemTime

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

impl Debug for UdpSocket

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

impl Debug for SocketAddr

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

impl Debug for BacktraceStatus

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

impl Debug for Output

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

impl Debug for SocketAddrV6

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

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

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

impl Debug for RecvTimeoutError

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

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

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

impl Debug for ReadDir

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

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

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

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

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

impl Debug for Ipv6MulticastScope

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

impl Debug for OsString

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

impl Debug for FileType

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

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

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

impl Debug for ArgsOs

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

impl Debug for CStr

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

impl Debug for Command

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

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

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

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

impl Debug for TcpStream

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

impl Debug for AddrParseError

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

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

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

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

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

impl Debug for Stdio

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

impl Debug for Permissions

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

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

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

impl Debug for ExitCode

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

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

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

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

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

impl Debug for ExitStatus

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

impl Debug for System

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

impl Debug for Stdin

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

impl Debug for Ipv4Addr

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

impl Debug for SeekFrom

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

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

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

impl Debug for IntoStringError

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

impl Debug for IpAddr

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

impl Debug for DirEntry

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

impl<T> Debug for Key<T>

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

impl Debug for WaitTimeoutResult

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

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

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

impl Debug for Shutdown

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

impl Debug for Error

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

impl Debug for AccessError

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

impl Debug for SocketAddr

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

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

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

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

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

impl Debug for VarError

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

impl Debug for OnceState

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

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

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

impl Debug for Stderr

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

impl Debug for SystemTimeError

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

impl<T> Debug for TrySendError<T>

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

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

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

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

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

impl Debug for UnixListener

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

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

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

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

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

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

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

impl Debug for File

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

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

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

impl Debug for Path

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

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

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

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

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

impl Debug for Args

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

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

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

impl Debug for ThreadId

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

impl Debug for VarsOs

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

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

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

impl Debug for UnixStream

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

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

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

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

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

impl Debug for StripPrefixError

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

impl Debug for ParseFloatError

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

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

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

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

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

impl Debug for AtomicI64

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

impl Debug for NonZeroU32

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

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

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

impl<T> Debug for AtomicPtr<T>

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

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

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

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

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

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

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

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

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

impl Debug for EscapeDefault

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Utf8Lossy

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

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

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

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

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

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

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

impl Debug for NonZeroI128

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

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

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

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

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

impl Debug for f32

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

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

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

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

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

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

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

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

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

impl Debug for __m256i

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

impl Debug for AtomicIsize

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

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

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

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

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

impl Debug for __m128d

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

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

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

impl Debug for TryFromIntError

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

impl Debug for AtomicI32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for RangeFull

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

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

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

impl Debug for i64

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

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

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

impl Debug for NonZeroI8

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

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

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

impl Debug for i32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for IntErrorKind

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

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

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

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

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

impl Debug for NonZeroI16

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

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

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

impl Debug for CannotReallocInPlace

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for i128

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

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

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

impl Debug for Layout

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

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

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

impl Debug for NonZeroU8

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

impl Debug for Utf8Error

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

impl Debug for __m128i

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

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

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

impl Debug for AtomicBool

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

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

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

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

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

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

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

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

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

impl Debug for Waker

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for SipHasher

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

impl Debug for str

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

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

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

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

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

impl Debug for NoneError

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

impl Debug for Alignment

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

impl Debug for __m128

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

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

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

impl Debug for ParseCharError

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

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

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

impl Debug for AtomicU16

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

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

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

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

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

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

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

impl Debug for AtomicU64

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

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

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

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

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

impl<T> Debug for Empty<T>

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

impl Debug for AtomicUsize

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

impl Debug for NonZeroIsize

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

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

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

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

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

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

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

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

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

impl Debug for CharTryFromError

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

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

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

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

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

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

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

impl Debug for Excess

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

impl Debug for AllocErr

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

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

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

impl Debug for u128

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

impl Debug for bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroU64

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

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

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

impl Debug for i16

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

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

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

impl Debug for __m256d

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

impl Debug for EscapeUnicode

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

impl Debug for ToUppercase

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

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

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

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

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

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

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

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

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

impl<H> Debug for BuildHasherDefault<H>

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

impl Debug for dyn Any + 'static

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

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

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

impl Debug for usize

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for c_void

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

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

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

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

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

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

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

impl Debug for u64

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

impl Debug for RawWaker

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

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

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

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

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

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

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

impl Debug for ParseBoolError

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

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

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

impl Debug for EscapeDebug

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

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

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

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

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

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

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

impl Debug for TypeId

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

impl Debug for NonZeroUsize

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

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

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

impl<T> Debug for Discriminant<T>

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

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

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

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

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

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

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

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

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

impl Debug for Ordering

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

impl<F> Debug for FromFn<F>

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

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

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

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

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

impl Debug for __m512d

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

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

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

impl Debug for BorrowMutError

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

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

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

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

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

impl Debug for LayoutErr

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

impl Debug for !

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

impl Debug for Error

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

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

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

impl Debug for dyn Any + 'static + Send

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

impl Debug for FpCategory

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

impl Debug for TryFromSliceError

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

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

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

impl Debug for AtomicI16

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

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

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

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

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

impl Debug for BorrowError

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

impl Debug for NonZeroI64

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

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

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

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

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

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

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

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

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

impl Debug for __m512

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

impl Debug for EscapeDefault

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

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

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

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

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

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

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

impl Debug for NonZeroU128

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for SearchStep

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

impl Debug for Ordering

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

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

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

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

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

impl Debug for u16

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

impl Debug for isize

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

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

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

impl Debug for i8

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

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicU32

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

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

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

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

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

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

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

impl Debug for char

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

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

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

impl Debug for ToLowercase

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

impl Debug for NonZeroU16

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

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

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

impl Debug for AtomicI8

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

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

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

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

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

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

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

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

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

impl Debug for __m512i

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

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

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

impl Debug for Infallible

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for ()

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

impl Debug for RawWakerVTable

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

impl Debug for PhantomPinned

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

impl Debug for Duration

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

impl Debug for CpuidResult

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

impl Debug for NonZeroI32

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

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

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

impl Debug for ParseIntError

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

impl Debug for UnicodeVersion

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

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

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

impl Debug for u8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for __m256

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

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

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

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

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

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

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

impl Debug for __m64

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

impl Debug for AtomicU8

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

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

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

impl Debug for u32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for f64

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

impl Debug for DecodeUtf16Error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for String

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for FromUtf8Error

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

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

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

impl Debug for FromUtf16Error

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

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

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

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

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

impl Debug for TryReserveError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LinkedList<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RangeMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Range<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Global

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Box<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for SymmetricDifference<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for PeekMut<'_, T> where
    T: Ord + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _Unwind_Reason_Code

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Frame

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Symbol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SymbolName<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BytesOrWideString<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Demangle<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryDemangleError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K> Debug for IntoIter<K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for VacantEntry<'_, K, V, S> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CollectionAllocErr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K> Debug for Drain<'_, K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilder<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RustcOccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for OccupiedEntry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RustcVacantEntry<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Debug,
    S: BuildHasher,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RawOccupiedEntryMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for Entry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RustcEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawVacantEntryMut<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Backtrace

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D> Debug for Context<D> where
    D: 'static + Send + Sync + Display, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SyncFailure<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Compat<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Frame

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BacktraceFrame

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Symbol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SymbolName<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Backtrace

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BytesOrWideString<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BacktraceSymbol

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Demangle<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryDemangleError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for statvfs64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for input_event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr_un

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for pthread_attr_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for nl_mmap_hdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for __timeval

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for statx_timestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for epoll_event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for dl_phdr_info

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for statfs64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for if_nameindex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for group

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for aiocb

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for addrinfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for arpreq

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for passwd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for nl_mmap_req

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for utsname

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for arpd_request

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for timeval

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rlimit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for user

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for msghdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for iovec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for arpreq_old

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for termios

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for in6_pktinfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf64_Phdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for af_alg_iv

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for lconv

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ipv6_mreq

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for servent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for utimbuf

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ucontext_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for statfs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for stat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf64_Sym

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for mallinfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for tms

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf32_Phdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for packet_mreq

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for spwd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr_in

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for siginfo_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for posix_spawn_file_actions_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ip_mreq

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _libc_fpxreg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for statx

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for input_mask

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for pthread_rwlock_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for fpos64_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for glob64_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for linger

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf64_Ehdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for timespec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _libc_fpstate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for cmsghdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for itimerspec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rusage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for statvfs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sched_param

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FILE

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rtentry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for posix_spawnattr_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for pthread_mutex_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for input_id

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for arphdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for genlmsghdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sembuf

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for mmsghdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for mntent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for nlmsghdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for itimerval

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for fsid_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for in6_addr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for msginfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for pollfd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for cpu_set_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for hostent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for input_absinfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for pthread_condattr_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for glob_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for dirent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for fpos_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for flock

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sysinfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for input_keymap_entry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf64_Chdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DIR

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for dqblk

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for timezone

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_replay

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_effect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for termios2

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf32_Ehdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr_vm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ucred

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr_storage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for pthread_rwlockattr_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf32_Chdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr_alg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sigevent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_rumble_effect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for protoent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_trigger

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dl_info

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for utmpx

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_ramp_effect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for pthread_cond_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_envelope

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rlimit64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for signalfd_siginfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf32_Shdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_condition_effect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for nlattr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for mq_attr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for fd_set

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr_in6

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for in_addr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf64_Shdr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for inotify_event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for nl_pktinfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sem_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for in6_rtmsg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for pthread_mutexattr_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_periodic_effect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ifaddrs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _libc_xmmreg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for stat64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for nlmsgerr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ff_constant_effect

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for stack_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for __exit_status

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for dirent64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for winsize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for tm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for shmid_ds

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for user_fpregs_struct

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr_nl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for mcontext_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for in_pktinfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elf32_Sym

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ipc_perm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sigset_t

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sigval

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sockaddr_ll

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for msqid_ds

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sigaction

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for user_regs_struct

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for MetadataBuilder<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetLoggerError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseLevelError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Record<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LevelFilter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for RecordBuilder<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ArgSettings

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for OsValues<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ArgMatches<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SubCommand<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ArgGroup<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Values<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AppSettings

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shell

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Prefix

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Colour

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for ANSIGenericString<'a, S> where
    S: 'a + Debug + ToOwned + ?Sized,
    <S as ToOwned>::Owned: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Suffix

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Infix

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Style

Styles have a special Debug implementation that only shows the fields that are set. Fields that haven’t been touched aren’t included in the output.

This behaviour gets bypassed when using the alternate formatting mode format!("{:#?}").

use ansi_term::Colour::{Red, Blue};
assert_eq!("Style { fg(Red), on(Blue), bold, italic }",
           format!("{:?}", Red.on(Blue).bold().italic()));

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Stream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StrSimError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for IntoWrapIter<'a, S> where
    S: WordSplitter + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NoHyphenation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'w, 'a, S> Debug for WrapIter<'w, 'a, S> where
    'a: 'w,
    S: 'w + WordSplitter + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HyphenSplitter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for Wrapper<'a, S> where
    S: WordSplitter + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<V> Debug for VecMap<V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Date

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RunMigrationsError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigInt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sqlite

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Interval

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U, V, Ret> Debug for UpdateStatement<T, U, V, Ret> where
    Ret: Debug,
    T: Debug,
    U: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ConnectionError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Query, Value> Debug for UncheckedBind<Query, Value> where
    Query: Debug,
    Value: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Text

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Numeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, Op> Debug for IncompleteInsertStatement<T, Op> where
    Op: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Float

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<ST> Debug for Nullable<ST> where
    ST: NotNull + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Integer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DatabaseErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for dyn DatabaseErrorInformation + 'static + Sync + Send

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Binary

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for now

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T, DB> Debug for DebugQuery<'a, T, DB> where
    DB: Backend,
    T: QueryFragment<DB>,
    <DB as Backend>::QueryBuilder: Default, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsNull

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Double

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Time

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SmallInt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<ST, T> Debug for SqlLiteral<ST, T> where
    ST: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnexpectedNullError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T, DB> Debug for Output<'a, T, DB> where
    DB: TypeMetadata,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<DB> Debug for RawBytesBindCollector<DB> where
    DB: Backend + TypeMetadata + Debug,
    <DB as TypeMetadata>::TypeMetadata: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U, Ret> Debug for DeleteStatement<T, U, Ret> where
    Ret: Debug,
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SqlQuery

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U, Op, Ret> Debug for InsertStatement<T, U, Op, Ret> where
    Op: Debug,
    Ret: Debug,
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TinyInt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MigrationError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LittleEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_backup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_index_info_sqlite3_index_constraint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_rtree_geometry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_context

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_pcache_page

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_mem_methods

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_file_sqlite3_io_methods

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_pcache_methods

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_index_info_sqlite3_index_orderby

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_pcache_methods2

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_vfs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_index_info_sqlite3_index_constraint_usage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_file

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_stmt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_vtab

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_mutex_methods

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_pcache

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_module

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_mutex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for __va_list_tag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_vtab_cursor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_index_info

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sqlite3_blob

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Numeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Tz> Debug for DateTime<Tz> where
    Tz: TimeZone, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveDateTime

The Debug output of the naive date and time dt is same to dt.format("%Y-%m-%dT%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn't matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveDate;

let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");

Leap seconds may also be used.

let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SecondsFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Tz> Debug for Date<Tz> where
    Tz: TimeZone, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveTime

The Debug output of the naive time t is same to t.format("%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn't matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveTime;

assert_eq!(format!("{:?}", NaiveTime::from_hms(23, 56, 4)),              "23:56:04");
assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(23, 56, 4, 12)),    "23:56:04.012");
assert_eq!(format!("{:?}", NaiveTime::from_hms_micro(23, 56, 4, 1234)),  "23:56:04.001234");
assert_eq!(format!("{:?}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");

Leap seconds may also be used.

assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parsed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InternalNumeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Weekday

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Utc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseWeekdayError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InternalFixed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Local

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveDate

The Debug output of the naive date d is same to d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

Example

use chrono::NaiveDate;

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for StrftimeItems<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FixedOffset

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pad

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for DelayedFormat<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Item<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Fixed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LocalResult<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsoWeek

The Debug output of the ISO week w is same to d.format("%G-W%V") where d is any NaiveDate value in that week.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5).iso_week()), "2015-W36");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  3).iso_week()), "0000-W01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31).iso_week()), "9999-W52");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(    0,  1,  2).iso_week()),  "-0001-W52");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31).iso_week()), "+10000-W52");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Duration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timespec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for TmFmt<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SteadyTime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutOfRangeError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ExtendedGcd<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FloatErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseFloatError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U128Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IgnoredAny

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I128Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SelectTimeoutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvTimeoutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendTimeoutError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReadyTimeoutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryReadyError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SelectedOperation<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TrySelectError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for TryIter<'a, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Select<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockReadGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ShardedLock<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unparker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockWriteGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AtomicCell<T> where
    T: Copy + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope, 'env> Debug for ScopedThreadBuilder<'scope, 'env> where
    'env: 'scope, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitGroup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope, T> Debug for ScopedJoinHandle<'scope, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'env> Debug for Scope<'env>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Backoff

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CachePadded<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Url

Debug the serialization of this URL.

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for OpaqueOrigin

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ByteSerialize<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PathSegmentsMut<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SyntaxViolation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Origin

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Host<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for UrlQuery<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Errors

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'text> Debug for InitialInfo<'text>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'text> Debug for BidiInfo<'text>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BidiClass

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParagraphInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsNormalized

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Array,
    <T as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PercentDecode<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F, P, R> Debug for Function<F, P, R> where
    F: Debug,
    P: Debug,
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LuaContext

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for LuaCodeFromReader<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for LuaCode<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for LuaFunctionCallError<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LuaError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<C, O> Debug for TuplePushError<C, O> where
    C: Debug,
    O: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<L> Debug for LuaTable<L> where
    L: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t, L, K, V> Debug for LuaTableIterator<'t, L, K, V> where
    K: Debug,
    L: 't + Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InsideCallback

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnyLuaString

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Void

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'lua> Debug for Lua<'lua>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnyHashableLuaValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnyLuaValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, L> Debug for UserdataOnStack<T, L> where
    L: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<L> Debug for PushGuard<L> where
    L: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<L> Debug for LuaFunction<L> where
    L: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<L> Debug for StringInLua<L> where
    L: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SOA

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DnsReply

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DnsError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Entry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidMethod

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidStatusCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Keys<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for OccupiedEntry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ToStrError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidHeaderValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Values<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Uri

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidUriParts

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parts

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidHeaderNameBytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parts

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HeaderName

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StatusCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HeaderValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Port<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PathAndQuery

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidHeaderValueBytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidUriBytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Response<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ValueIter<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidHeaderName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Authority

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ValueIterMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Scheme

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parts

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ValueDrain<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for HeaderMap<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ValuesMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Extensions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Request<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Method

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for GetAll<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidUri

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bytes

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Iter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Take<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for Writer<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for Reader<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BytesMut

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<L, R> Debug for Either<L, R> where
    L: Debug,
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OnUpgrade

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, S> Debug for Connection<I, S, Exec> where
    S: Service, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Http<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, S> Debug for Server<I, S, Exec> where
    I: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidNameError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddrStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for HttpConnector<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<C, B> Debug for Client<C, B>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, S, E> Debug for Serve<I, S, E> where
    E: Debug,
    I: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddrIncoming

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sender

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Destination

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GaiFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Name

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Connected

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Upgraded

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HttpInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendRequest<B>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Parts<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for Parts<T, S> where
    S: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GaiResolver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TokioThreadpoolGaiFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TokioThreadpoolGaiResolver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F, E> Debug for Connecting<I, F, E> where
    E: Debug,
    F: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for Builder<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Chunk

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Payload + 'static,
    T: AsyncRead + AsyncWrite + Debug + Send + 'static, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GaiAddrs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Body

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Parts<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Receiver<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Either<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, C, D> Debug for Join4<A, B, C, D> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    D: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug,
    <D as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<F> Debug for Shared<F> where
    F: Future + Debug,
    <F as Future>::Item: Debug,
    <F as Future>::Error: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for SelectNext<A, B> where
    A: Future + Debug,
    B: Debug + Future<Item = <A as Future>::Item, Error = <A as Future>::Error>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Select2<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, C, D, E> Debug for Join5<A, B, C, D, E> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    D: Future<Error = <A as Future>::Error> + Debug,
    E: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug,
    <D as Future>::Item: Debug,
    <E as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S, F, U> Debug for ForEach<S, F, U> where
    F: Debug,
    S: Debug,
    U: Debug + IntoFuture,
    <U as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I1, I2> Debug for MergedItem<I1, I2> where
    I1: Debug,
    I2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, E> Debug for SinkFromErr<S, E> where
    E: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, U, F, Fut> Debug for With<S, U, F, Fut> where
    F: Debug + FnMut(U) -> Fut,
    Fut: Debug + IntoFuture,
    S: Debug + Sink,
    U: Debug,
    <Fut as IntoFuture>::Future: Debug,
    <S as Sink>::SinkItem: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BiLock<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S1, S2> Debug for Zip<S1, S2> where
    S1: Stream + Debug,
    S2: Stream + Debug,
    <S1 as Stream>::Item: Debug,
    <S2 as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Skip<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Collect<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AsyncSink<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Fanout<A, B> where
    A: Sink + Debug,
    B: Sink + Debug,
    <A as Sink>::SinkItem: Debug,
    <B as Sink>::SinkItem: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for SpawnHandle<I, E>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Repeat<T, E> where
    E: Debug,
    T: Debug + Clone, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Send<S> where
    S: Sink + Debug,
    <S as Sink>::SinkItem: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AtomicTask

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Flatten<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for MapErr<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, P, R> Debug for SkipWhile<S, P, R> where
    P: Debug,
    R: Debug + IntoFuture,
    S: Debug + Stream,
    <R as IntoFuture>::Future: Debug,
    <S as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for SplitStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Concat<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<I> Debug for IterResult<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Task

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for FutureSender<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SelectAll<A> where
    A: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BiLockAcquire<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for SendAll<T, U> where
    T: Debug,
    U: Stream + Debug,
    <U as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Once<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Async<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for LoopFn<A, F> where
    A: Debug + IntoFuture,
    F: Debug,
    <A as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SharedItem<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F, U> Debug for OrElse<S, F, U> where
    F: Debug,
    S: Debug,
    U: Debug + IntoFuture,
    <U as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for PollFn<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, C> Debug for Join3<A, B, C> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Take<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Select<A, B> where
    A: Future + Debug,
    B: Debug + Future<Item = <A as Future>::Item, Error = <A as Future>::Error>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Flatten<A> where
    A: Future + Debug,
    <A as Future>::Item: IntoFuture,
    <<A as IntoFuture>::Item as IntoFuture>::Future: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BiLockAcquired<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for ExecuteError<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for SplitSink<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S1, S2> Debug for Chain<S1, S2> where
    S1: Debug,
    S2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Execute<S> where
    S: Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for OrElse<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for IterOk<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SharedError<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Execute<S> where
    S: Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S1, S2> Debug for Select<S1, S2> where
    S1: Debug,
    S2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ReuniteError<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for Then<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Flush<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for BiLockGuard<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for SpawnHandle<I, E>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Join<A, B> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for Inspect<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for Loop<T, S> where
    S: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Wait<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for FilterMap<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Empty<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    F: Debug,
    Fut: Debug + IntoFuture,
    T: Debug,
    <Fut as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for FuturesUnordered<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for FutureResult<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for StreamFuture<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, F> Debug for IterMut<'a, F> where
    F: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Buffered<S> where
    S: Stream + Debug,
    <S as Stream>::Item: IntoFuture,
    <<S as Stream>::Item as IntoFuture>::Future: Debug,
    <<S as Stream>::Item as IntoFuture>::Item: Debug,
    <<S as Stream>::Item as IntoFuture>::Error: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for NotifyHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Concat2<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S, F, U> Debug for AndThen<S, F, U> where
    F: Debug,
    S: Debug,
    U: Debug + IntoFuture,
    <U as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, E> Debug for FromErr<S, E> where
    E: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for SpawnHandle<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for CatchUnwind<S> where
    S: Debug + Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Buffer<S> where
    S: Sink + Debug,
    <S as Sink>::SinkItem: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Fuse<A> where
    A: Future + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Wait<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SelectOk<A> where
    A: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for Filter<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for Map<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Spawn<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for MapErr<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Chunks<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug,
    <S as Stream>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for FlattenStream<F> where
    F: Future + Debug,
    <F as Future>::Item: Stream,
    <F as Future>::Item: Debug,
    <<F as Future>::Item as Stream>::Error == <F as Future>::Error, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for IntoStream<F> where
    F: Future + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, E> Debug for FromErr<A, E> where
    A: Debug + Future,
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for InspectErr<S, F> where
    F: Debug,
    S: Debug + Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for AndThen<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for Forward<T, U> where
    T: Stream + Debug,
    U: Debug,
    <T as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for Execute<F> where
    F: Future + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for JoinAll<I> where
    I: IntoIterator,
    <I as IntoIterator>::Item: IntoFuture,
    <<I as IntoIterator>::Item as IntoFuture>::Future: Debug,
    <<I as IntoIterator>::Item as IntoFuture>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for Map<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Empty<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for FuturesOrdered<T> where
    T: Debug + Future, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Iter<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for SendError<T, E>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LocalKey<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExecuteErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Sender<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, P, R> Debug for TakeWhile<S, P, R> where
    P: Debug,
    R: Debug + IntoFuture,
    S: Debug + Stream,
    <R as IntoFuture>::Future: Debug,
    <S as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Peekable<S> where
    S: Stream + Debug,
    <S as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for BufferUnordered<S> where
    S: Stream + Debug,
    <S as Stream>::Item: IntoFuture,
    <<S as Stream>::Item as IntoFuture>::Future: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F, R> Debug for Lazy<F, R> where
    F: Debug,
    R: IntoFuture + Debug,
    <R as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for PollFn<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for TaskRc<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Fuse<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F, Fut, T> Debug for Fold<S, F, Fut, T> where
    F: Debug,
    Fut: Debug + IntoFuture,
    S: Debug,
    T: Debug,
    <Fut as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Canceled

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S1, S2> Debug for Merge<S1, S2> where
    S1: Debug,
    S2: Stream + Debug,
    <S2 as Stream>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F, U> Debug for Then<S, F, U> where
    F: Debug,
    S: Debug,
    U: Debug + IntoFuture,
    <U as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for Execute<F> where
    F: Future + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for SinkMapErr<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, U, F, St> Debug for WithFlatMap<S, U, F, St> where
    F: Debug + FnMut(U) -> St,
    S: Sink + Debug,
    St: Debug + Stream<Item = <S as Sink>::SinkItem, Error = <S as Sink>::SinkError>,
    U: Debug,
    <S as Sink>::SinkItem: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for Inspect<S, F> where
    F: Debug,
    S: Debug + Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for SpawnHandle<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Run

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for CatchUnwind<F> where
    F: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for CpuPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for CpuFuture<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pong

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ReleaseCapacity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvStream

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for PushPromises

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendResponse<B> where
    B: Debug + IntoBuf,
    <B as IntoBuf>::Buf: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendRequest<B> where
    B: IntoBuf, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendStream<B> where
    B: Debug + IntoBuf,
    <B as IntoBuf>::Buf: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PushedResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PingPong

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PushPromise

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ping

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B> where
    B: Debug + IntoBuf,
    T: AsyncRead + AsyncWrite + Debug,
    <B as IntoBuf>::Buf: Debug,
    <B as IntoBuf>::Buf: IntoBuf, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Debug + IntoBuf,
    T: Debug,
    <B as IntoBuf>::Buf: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B> where
    B: Debug + IntoBuf,
    T: AsyncRead + AsyncWrite + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Reason

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for ReadySendRequest<B> where
    B: Debug + IntoBuf, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Debug + IntoBuf,
    T: AsyncRead + AsyncWrite + Debug,
    <B as IntoBuf>::Buf: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ReadToEnd<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, T> Debug for ReadExact<A, T> where
    A: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, T> Debug for WriteAll<A, T> where
    A: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Lines<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AllowStdIo<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Flush<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Window<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for Framed<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for Read<R, T> where
    R: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Shutdown<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for FramedParts<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, W> Debug for Copy<R, W> where
    R: Debug,
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ReadUntil<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, D> Debug for FramedRead<T, D> where
    D: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for FramedWrite<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for String<T> where
    T: AsRef<[u8]>, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T, S> Debug for Intersection<'a, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T, S> Debug for Difference<'a, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T, S1, S2> Debug for SymmetricDifference<'a, T, S1, S2> where
    S1: BuildHasher,
    S2: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for Keys<'a, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T, S> Debug for Union<'a, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for IndexSet<T, S> where
    S: BuildHasher,
    T: Debug + Hash + Eq, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for Entry<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for Values<'a, K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for Iter<'a, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V, S> Debug for IndexMap<K, V, S> where
    K: Debug + Hash + Eq,
    S: BuildHasher,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for OccupiedEntry<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for VacantEntry<'a, K, V> where
    K: 'a + Debug,
    V: 'a, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for Collect<T, U> where
    T: Debug + BufStream,
    U: Debug + FromBufStream<<T as BufStream>::Item>,
    <U as FromBufStream<<T as BufStream>::Item>>::Builder: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Limit<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoStream<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CollectBytesError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LimitError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SizeHint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CollectVecError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for CollectError<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'headers, 'buf> Debug for Response<'headers, 'buf> where
    'buf: 'headers, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidChunkSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Status<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'headers, 'buf> Debug for Request<'headers, 'buf> where
    'buf: 'headers, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Header<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UdpBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Runtime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Runtime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FrameTooBig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LengthDelimitedCodec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Spawn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TaskExecutor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixReady

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for EventedFd<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Iter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ready

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Events

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetReadiness

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Token

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Registration

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Poll

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UdpSocket

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollOpt

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for BytesCodec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LinesCodec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RunTimeoutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RunError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BlockError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<P> Debug for CurrentThread<P> where
    P: Park, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, P> Debug for Entered<'a, P> where
    P: Park, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Turn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TaskExecutor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TurnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EnterError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkThread

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkThread

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpawnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultExecutor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Enter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unparker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope, 'env> Debug for ScopedThreadBuilder<'scope, 'env> where
    'env: 'scope, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ShardedLock<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AtomicCell<T> where
    T: Copy + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Backoff

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'env> Debug for Scope<'env>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitGroup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockReadGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockWriteGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CachePadded<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope, T> Debug for ScopedJoinHandle<'scope, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for MetadataFuture<P> where
    P: Debug + AsRef<Path> + Send + 'static, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for ReadFile<P> where
    P: 'static + Send + AsRef<Path> + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for SymlinkMetadataFuture<P> where
    P: Debug + AsRef<Path> + Send + 'static, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for OpenFuture<P> where
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P, Q> Debug for RenameFuture<P, Q> where
    P: Debug + AsRef<Path>,
    Q: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for CreateDirFuture<P> where
    P: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SeekFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DirEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MetadataFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for RemoveDirFuture<P> where
    P: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for ReadLinkFuture<P> where
    P: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Stdin

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for ReadDirFuture<P> where
    P: Debug + AsRef<Path> + Send + 'static, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P, Q> Debug for HardLinkFuture<P, Q> where
    P: Debug + AsRef<Path>,
    Q: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReadDir

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for CreateFuture<P> where
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for File

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for RemoveFileFuture<P> where
    P: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Stderr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P, C> Debug for WriteFile<P, C> where
    C: AsRef<[u8]> + Debug,
    P: 'static + Send + AsRef<Path> + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CloneFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Stdout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for CreateDirAllFuture<P> where
    P: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for SetPermissionsFuture<P> where
    P: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P, Q> Debug for SymlinkFuture<P, Q> where
    P: Debug + AsRef<Path>,
    Q: Debug + AsRef<Path>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Worker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for SpawnHandle<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BlockingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultPark

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WorkerId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sender

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultUnpark

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Worker<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Stealer<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Steal<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Injector<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'g, T> Debug for Shared<'g, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'g, T, P> Debug for CompareAndSetError<'g, T, P> where
    P: Pointer<T> + Debug,
    T: 'g, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Collector

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Guard

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Atomic<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Owned<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Always

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, S> Debug for ScopeGuard<T, F, S> where
    F: FnOnce(T),
    S: Strategy,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PopError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SegQueue<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ArrayQueue<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for PushError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Registration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Reactor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Background

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetFallbackError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for PollEvented<E> where
    E: Debug + Evented, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Turn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Once

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Condvar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitTimeoutResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OnceState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for RwLock<R, T> where
    R: RawRwLock,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockWriteGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MutexGuard<'a, R, T> where
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, G, T> Debug for ReentrantMutex<R, G, T> where
    G: GetThreadId,
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedMutexGuard<'a, R, T> where
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockReadGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockWriteGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, G, T> Debug for ReentrantMutexGuard<'a, R, G, T> where
    G: 'a + GetThreadId,
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockReadGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockUpgradableReadGuard<'a, R, T> where
    R: 'a + RawRwLockUpgrade,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for Mutex<R, T> where
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, G, T> Debug for MappedReentrantMutexGuard<'a, R, G, T> where
    G: 'a + GetThreadId,
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RequeueOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedTrySendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LockGuard<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Permit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Lock<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Ref<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for AcquireError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnboundedRecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Semaphore

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SendError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AtomicTask

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TrySendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnboundedSendError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryAcquireError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Incoming

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ConnectFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Interval

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for DelayQueue<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Delay

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, N> Debug for Timer<T, N> where
    N: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Expired<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Error<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Throttle<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Clock

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Turn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Timeout<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ThrottleError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Key

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RecvDgram<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<C> Debug for UdpFramed<C> where
    C: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UdpSocket

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendDgram<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, P> Debug for SendDgram<T, P> where
    P: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Incoming

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RecvDgram<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UCred

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, C> Debug for UnixDatagramFramed<A, C> where
    A: Debug,
    C: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ConnectFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixDatagram

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixDatagram

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Taker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Closed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SharedGiver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Giver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TryLock<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Locked<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for MaybeHttpsStream<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for HttpsConnector<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Log<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Input<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Reader<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EndOfInput

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Algorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EcdsaVerificationAlgorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EcdsaSigningAlgorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Salt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SystemRandom

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublicKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Key

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unspecified

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RsaKeyPair

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Algorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for UnparsedPublicKey<B> where
    B: Debug + AsRef<[u8]>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<N> Debug for OpeningKey<N> where
    N: NonceSequence, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RsaParameters

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ed25519KeyPair

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EdDSAParameters

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Algorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<N> Debug for SealingKey<N> where
    N: NonceSequence, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Algorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnboundKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Digest

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Prk

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for RsaPublicKeyComponents<B> where
    B: AsRef<[u8]> + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RsaSubjectPublicKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, L> Debug for Okm<'a, L> where
    L: KeyType + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LessSafeKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EcdsaKeyPair

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Algorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyRejected

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Algorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TestCase

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EphemeralPrivateKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Context

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for RwLockUpgradeableGuard<'a, T> where
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RwLock<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for MutexGuard<'a, T> where
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for RwLockWriteGuard<'a, T> where
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for RwLockReadGuard<'a, T> where
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Once<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HashAlgorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MessagePayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NewSessionTicketPayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BorrowMessage<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HandshakeMessagePayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignatureAlgorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerSession

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NewSessionTicketPayloadTLS13

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ECCurveType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerSessionValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientECDHParams

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientExtension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExtensionType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerNameType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PayloadU8

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Message

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Payload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NamedCurve

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignatureScheme

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientCertificateType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientSession

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertificateRequestPayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ECParameters

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TLSError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NewSessionTicketExtension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RootCertStore

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NamedGroup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HeartbeatMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PresharedKeyIdentity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyUpdateRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OCSPCertificateStatusRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for u24

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientSessionKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertificateStatusRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyShareEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BulkAlgorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertificateStatusType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SupportedCipherSuite

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlertLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerNamePayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerHelloPayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerExtension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CipherSuite

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyExchangeAlgorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertificateExtension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlertMessagePayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PSKKeyExchangeMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HeartbeatMessageType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlertDescription

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertificateStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HelloRetryExtension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChangeCipherSpecPayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerKeyExchangePayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Compression

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientHelloPayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertificatePayloadTLS13

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProtocolVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PresharedKeyOffer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HandshakePayload

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Certificate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertReqExtension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PayloadU24

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HelloRetryRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PrivateKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DigitallySignedStruct

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PayloadU16

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ServerECDHParams

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientSessionValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ECPointFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HandshakeType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertificateEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnknownExtension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ECDHEServerKeyExchange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Random

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertificateRequestPayloadTLS13

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SessionID

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for TLSServerTrustAnchors<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_> Debug for DNSNameRef<'_>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for TrustAnchor<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidDNSNameError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for TLSClientTrustAnchors<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Time

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DNSName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CharacterSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for EncoderWriter<'a, W> where
    W: Write, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodeError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<IO> Debug for TlsStream<IO> where
    IO: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<IO> Debug for TlsStream<IO> where
    IO: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TlsState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V, S> Debug for LruCache<K, V, S> where
    K: Eq + Hash + Debug,
    S: BuildHasher,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, S> Debug for LinkedHashMap<A, B, S> where
    A: Eq + Hash + Debug,
    B: Debug,
    S: BuildHasher, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Returns a string that lists the key-value pairs in insertion order.

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Token

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LowerQuery

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LowerName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RrKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodeError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodeKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BitOrder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpecificationError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodePartial

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Translate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Wrap

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Encoding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Specification

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for SubTrie<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for Trie<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for SubTrieMut<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BigEndian<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LittleEndian<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NibbleVec

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Cauchy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bernoulli

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnitCircle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UniformDuration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for IndexVecIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnitSphereSurface

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StepRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pareto

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gamma

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StudentT

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dirichlet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EntropyRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IndexVecIntoIter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S, T> Debug for SliceChooseIter<'a, S, T> where
    S: 'a + Debug + ?Sized,
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Normal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Beta

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for UniformInt<X> where
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Binomial

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BernoulliError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChiSquared

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenClosed01

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IndexVec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WeightedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for WeightedIndex<X> where
    X: SampleUniform + PartialOrd<X> + Debug,
    <X as SampleUniform>::Sampler: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D, R, T> Debug for DistIter<D, R, T> where
    D: Debug,
    R: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Weibull

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Triangular

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for WeightedIndex<W> where
    W: Weight + Debug,
    Uniform<W>: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StandardNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for UniformFloat<X> where
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FisherF

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Alphanumeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for Uniform<X> where
    X: SampleUniform + Debug,
    <X as SampleUniform>::Sampler: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LogNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Poisson

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Open01

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Standard

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for ReadRng<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StdRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BlockRng<R> where
    R: BlockRngCore + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OsRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BlockRng64<R> where
    R: BlockRngCore + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha8Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha12Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha20Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha20Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha12Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha8Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DS

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SupportedAlgorithms

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UpdateScope

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Selector

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DNSSECRData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslErrorStack

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DigestType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MessageType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Message

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Query

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OPENPGPKEY

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'r> Debug for RrsetRecords<'r>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DNSClass

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CAA

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProtoErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SOA

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Algorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecordType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecordSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyUsage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Algorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SIG

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SRV

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Record

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NSEC3PARAM

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EdnsCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TXT

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MX

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Edns

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProtoError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Name

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CertUsage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EdnsOption

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FingerprintType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NSEC3

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Matching

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unspecified

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SSHFP

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TLSA

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Protocol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DnsResponse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyTrust

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OPT

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Label

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NAPTR

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Header

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KEY

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NULL

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DNSSECRecordType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NSEC

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Property

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DNSKEY

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Nsec3HashAlgorithm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockAddr

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Socket

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for DomainIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Lookup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Family

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ScopedIp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Network

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddrParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X, E> Debug for Context<X, E> where
    E: Debug,
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompactFormatter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Map<String, Value>

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Category

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Number

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SearchResponse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EntryType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DownloadResponse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LatestResponse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WhoamiResponse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublishResponse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for License

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleID

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Source

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleInfoResponse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Metadata

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublishRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for VerboseError<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Err<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompareResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Needed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VerboseErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Endianness

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RoundingKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Result<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CapacityError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayString<A> where
    A: Array<Item = u8>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for StrictApiResponse<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ApiError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Header

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HeaderMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EntryType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unpacked

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OldHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GnuSparseHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GnuHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UstarHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FileTime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnsupportedPlatformError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W, E> Debug for Encoder<W, E> where
    E: Debug,
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Finish<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Code

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExtraSubField

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Header

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for EncodeOptions<E> where
    E: Debug + Lz77Encode, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W, E> Debug for Encoder<W, E> where
    E: Debug,
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Header

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HeaderBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Lz77WindowSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Os

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for EncodeOptions<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultLz77Encoder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for MultiDecoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AutoFinishUnchecked<T> where
    T: Complete + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for EncodeOptions<E> where
    E: Debug + Lz77Encode, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExtraField

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NoCompressionLz77Encoder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AutoFinish<T> where
    T: Complete + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Hasher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpNetwork

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NetworkSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpNetworkError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv4Network

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6Network

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Blake2s

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarBlake2s

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarBlake2b

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Blake2b

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidOutputSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, N> Debug for GenericArrayIter<T, N> where
    N: ArrayLength<T>,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, N> Debug for GenericArray<T, N> where
    N: ArrayLength<T>,
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<U> Debug for NInt<U> where
    U: NonZero + Unsigned + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Greater

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Z0

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UTerm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ATerm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Less

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<U, B> Debug for UInt<U, B> where
    B: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<U> Debug for PInt<U> where
    U: NonZero + Unsigned + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for B1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for B0

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Equal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<V, A> Debug for TArr<V, A> where
    A: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidKeyLength

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MacError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Choice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DirEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, P> Debug for FilterEntry<I, P> where
    I: Debug,
    P: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WalkDir

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IntoIter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Color

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColoredString

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Spanned<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Datetime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DatetimeParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Map<String, Value>

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for X509Name<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for UniqueIdentifier<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for AlgorithmIdentifier<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for TbsCertificate<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Nid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SubjectPublicKeyInfo<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BasicConstraints

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Validity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NidError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for X509Extension<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for AttributeTypeAndValue<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for X509Certificate<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for X509Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for RelativeDistinguishedName<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PEMError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HexU16

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for HexSlice<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for HexU8

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for BerError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BitStringObject<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BerObjectContent<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BerTag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BerObjectHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BerObject<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Oid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigInt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseBigIntError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigUint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sign

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Traits

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepresentedCountry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Country

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Isp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Postal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Continent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Asn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MaxMindDBError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Country

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DensityIncome

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnonymousIp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Subdivision

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Location

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Metadata

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for City

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ConnectionType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for City

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Domain

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Bgra<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HDRMetadata

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rgb<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageOutputFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Buffer, P> Debug for ViewMut<Buffer, P> where
    Buffer: Debug + AsMut<[<P as Pixel>::Subpixel]>,
    P: Pixel + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Bgr<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SampleEncoding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DXTVariant

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ArbitraryHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SampleLayout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Buffer> Debug for FlatSamples<Buffer> where
    Buffer: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PNMSubtype

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BitmapHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P, Container> Debug for ImageBuffer<P, Container> where
    Container: Debug,
    P: Pixel + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rgba<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LumaA<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Buffer, P> Debug for View<Buffer, P> where
    Buffer: Debug + AsRef<[<P as Pixel>::Subpixel]>,
    P: Pixel + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RGBE8Pixel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for HDRDecoder<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ArbitraryTuplType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for HDRAdapter<R> where
    R: BufRead + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Luma<T> where
    T: Primitive + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Frame

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixmapHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NormalForm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GraymapHeader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseRatioError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Ratio<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Decoded<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorOutput

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Block

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StreamingDecoder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Extensions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DisposalMethod

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemoryLimit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Extension

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Frame<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: BitReader + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LsbReader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for DecoderEarlyChange<R> where
    R: BitReader + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsbReader

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImageInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixelFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnsupportedFeature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Repeat<T> where
    T: Send + Clone + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for Inspect<I, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D, S> Debug for Split<D, S> where
    D: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Zip<A, B> where
    A: IndexedParallelIterator + Debug,
    B: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for Iter<'a, K, V> where
    K: 'a + Sync + Eq + Hash + Debug,
    V: 'a + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Chunks<I> where
    I: Debug + IndexedParallelIterator, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for Map<I, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for Interleave<I, J> where
    I: Debug + IndexedParallelIterator,
    J: Debug + IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for PanicFuse<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for ZipEq<A, B> where
    A: IndexedParallelIterator + Debug,
    B: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Iter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Sync + Eq + Hash + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Copied<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for Update<I, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, U, F> Debug for FoldWith<I, U, F> where
    I: ParallelIterator + Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Intersperse<I> where
    I: Debug + ParallelIterator,
    <I as ParallelIterator>::Item: Clone,
    <I as ParallelIterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Send + Eq + Hash + Debug,
    V: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T, P> Debug for SplitMut<'data, T, P> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Send + Ord + Debug,
    V: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, U, F> Debug for TryFoldWith<I, U, F> where
    I: ParallelIterator + Debug,
    U: Try,
    <U as Try>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch, P> Debug for Split<'ch, P> where
    P: Pattern + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for Chunks<'data, T> where
    T: 'data + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, ID, F> Debug for Fold<I, ID, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Skip<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, T, F> Debug for MapWith<I, T, F> where
    I: ParallelIterator + Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for WhileSome<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, INIT, F> Debug for MapInit<I, INIT, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T, P> Debug for Split<'data, T, P> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for CharIndices<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Iter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for SplitWhitespace<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Ord + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, P> Debug for FilterMap<I, P> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for ChunksMut<'data, T> where
    T: 'data + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Eq + Hash + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Empty<T> where
    T: Send, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Sync + Ord + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for MaxLen<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch, P> Debug for MatchIndices<'ch, P> where
    P: Pattern + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Enumerate<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Chain<A, B> where
    A: Debug + ParallelIterator,
    B: Debug + ParallelIterator<Item = <A as ParallelIterator>::Item>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for Iter<'data, T> where
    T: 'data + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Flatten<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch, P> Debug for Matches<'ch, P> where
    P: Pattern + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Iter> Debug for IterBridge<Iter> where
    Iter: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for Lines<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for Iter<'a, K, V> where
    K: 'a + Sync + Ord + Debug,
    V: 'a + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Once<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for IterMut<'a, K, V> where
    K: 'a + Sync + Eq + Hash + Debug,
    V: 'a + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, K, V> Debug for IterMut<'a, K, V> where
    K: 'a + Sync + Ord + Debug,
    V: 'a + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for FlatMap<I, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Cloned<I> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, P> Debug for Filter<I, P> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch, P> Debug for SplitTerminator<'ch, P> where
    P: Pattern + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for Chars<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for MinLen<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<U, I, ID, F> Debug for TryFold<I, U, ID, F> where
    I: ParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for Windows<'data, T> where
    T: 'data + Sync + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Rev<I> where
    I: IndexedParallelIterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for InterleaveShortest<I, J> where
    I: Debug + IndexedParallelIterator,
    J: Debug + IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RepeatN<T> where
    T: Send + Clone + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Sync + Ord + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'data, T> Debug for IterMut<'data, T> where
    T: 'data + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for EncodeUtf16<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Ord + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'ch> Debug for Bytes<'ch>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Take<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for ThreadPoolBuilder<S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPool

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'scope> Debug for Scope<'scope>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for FnContext

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Configuration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPoolBuildError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope> Debug for ScopeFifo<'scope>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ArrayQueue<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PopError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SegQueue<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for PushError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DisposeOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Transformations

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BlendOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutputInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BitDepth

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Limits

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Decoded

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PixelDimensions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FrameControl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Compression

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Info

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EncodingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AnimationControl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Compression

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpecialOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MatchingType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TiffError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PlanarConfiguration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Entry

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionMethod

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Limits

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TiffFormatError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug + Read + Seek, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodingResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PhotometricInterpretation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TiffUnsupportedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SRational

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Rational

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DateTime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Field<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Context

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Writer<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Value<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Selector

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Node

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for NodeDataRef<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Selectors

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for NodeEdge<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Attribute

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Comments<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DocumentData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Elements<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Doctype

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Attributes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Siblings

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ancestors

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExpandedName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ElementData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for TextNodes<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NodeRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NodeData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Descendants

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Traverse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Token<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Color

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Delimiters

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'i, T> Debug for ParseErrorKind<'i, T> where
    T: 'i + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TokenSerializationType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SourceLocation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnicodeRange

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for ParserState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'i> Debug for BasicParseErrorKind<'i>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'i> Debug for BasicParseError<'i>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'i, E> Debug for ParseError<'i, E> where
    E: 'i + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SourcePosition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for CowRcStr<'a>

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for RGBA

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Notation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for OrderedMap<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Set<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for OrderedSet<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for Map<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SipHasher24

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SipHasher13

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SipHasher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SipHasher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SipHasher13

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SipHasher24

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Hash128

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AttrValueKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Token

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RawKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for State

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ScriptEscapeKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TagKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DoctypeIdKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Doctype

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Handle> Debug for TokenSinkResult<Handle> where
    Handle: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NextParserState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ExpandedName<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BufferQueue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuirksMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Node

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for NodeData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SmallCharSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QualName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Attribute

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Static> Debug for Atom<Static> where
    Static: StaticAtomSet, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Latin1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WTF8

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UTF8

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F, A> Debug for Tendril<F, A> where
    A: Atomicity,
    F: SliceFormat + Default + Debug,
    <F as SliceFormat>::Slice: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SubtendrilError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ASCII

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Meaning

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Codepoint<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BufReadDecoderError<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Incomplete

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for DecodeError<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParsedCaseSensitivity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Impl> Debug for SelectorList<Impl> where
    Impl: SelectorImpl + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpaqueElement

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Combinator

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Impl> Debug for SelectorIter<'a, Impl> where
    Impl: SelectorImpl, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuirksMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AncestorHashes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ElementSelectorFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Impl> Debug for Component<Impl> where
    Impl: SelectorImpl, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CaseSensitivity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Impl> Debug for Selector<Impl> where
    Impl: SelectorImpl, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VisitedHandlingMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'i> Debug for SelectorParseErrorKind<'i>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for CountingBloomFilter<S> where
    S: BloomStorage, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Impl> Debug for AttrSelectorWithOptionalNamespace<Impl> where
    Impl: SelectorImpl, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MatchingMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Impl> Debug for LocalName<Impl> where
    Impl: SelectorImpl, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FxHasher64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FxHasher32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FxHasher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<H> Debug for HeaderWithLength<H> where
    H: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RawOffsetArc<T> where
    T: 'static + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for NonZeroPtrMut<T> where
    T: 'static + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<H, T> Debug for HeaderSlice<H, T> where
    H: Debug,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ThinBoxedSlice<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HistoryDuplicates

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Movement

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EditMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<H> Debug for Editor<H> where
    H: Helper, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for At

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompletionType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BellStyle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutputStreamType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CharSearch

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Direction

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Anchor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Quote

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Cmd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyPress

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LineBuffer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Word

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GraphemeIncomplete

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RcvBufForce

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for AioCb<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AlgSetKey<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MapFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AioCancelStat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMulticastLoop

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AioFsyncMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddressFamily

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CloneFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LioOpcode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SysconfVar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SealFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FdFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollFd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6Addr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MntFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsgFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlgAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MmapAdvise

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6MembershipRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpAddMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Request

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FchmodatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LioMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SendTimeout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PtyMaster

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AtFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MlockAllFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PathconfVar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv4Addr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReceiveTimestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaFmt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InetAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpNoDelay

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BaudRate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SndBuf

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeepAlive

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LinkAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlgSetAeadAuthSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UtimensatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RcvBuf

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OriginalDst

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Errno

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigevNotify

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitPidFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddWatchFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mark

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpKeepIdle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceAddressIterator

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NetlinkAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Whence

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigEvent

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceAddress

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignalFd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dir

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpliceFFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MQ_OFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutputFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ForkptyResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigHandler

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FallocateFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EfdFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlushArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlowArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for LioCb<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SaFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigmaskHow

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'d> Debug for Iter<'d>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpDropMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ControlFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReuseAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimeSpec

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for MsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PeerCredentials

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProtFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReceiveTimeout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SfdFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemFdCreateFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimeVal

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for UnixCredentials

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Options

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReusePort

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FdFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Buffer<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SockType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptConn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RebootMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleInitFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaValidFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpTransparent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6DropMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DeleteModuleFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AccessFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ForkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv4PacketInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Entry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Linger

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OobInline

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6RecvPacketInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMembershipRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SndBufForce

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Inotify

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Uid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6AddMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InitFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PassCred

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InputFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FchownatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollCreateFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMulticastTtl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockProtocol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpCongestion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpecialCharacterIndices

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WatchDescriptor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SocketError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Broadcast

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Void

fn fmt(&self, &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Capability

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CapSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for DisplayChain<'a, T> where
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Iter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Errno

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for AccessFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Statfs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollCreateFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InitFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SaFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FdFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceAddress

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UtimensatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Buffer<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SealFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimeVal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollFd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RcvBufForce

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FchownatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpCongestion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMulticastTtl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WatchDescriptor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitPidFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mark

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LinkAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignalIterator

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Uid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SndBufForce

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CmsgSpace<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6Addr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddWatchFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpNoDelay

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Broadcast

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dir

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FsType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMulticastLoop

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UContext

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Statvfs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeepAlive

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6MembershipRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigmaskHow

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddressFamily

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for AioCb<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for CloneFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MlockAllFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlushArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BaudRate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SfdFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MQ_OFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RebootMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ControlMessage<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnlinkatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ControlFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PathconfVar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimeSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FchmodatFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReuseAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6AddMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6DropMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for RecvMsg<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SendTimeout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RcvBuf

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FdFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AtFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutputFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6RecvPacketInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PassCred

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpDropMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for CmsgIterator<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Request

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EfdFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SysconfVar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReceiveTimestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AioFsyncMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MqAttr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemFdCreateFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigHandler

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv4Addr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsgFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigevNotify

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixCredentials

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FdSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptConn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InputFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigAction

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LioMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv4PacketInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RemoteIoVec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MmapAdvise

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FallocateFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ControlMessageOwned

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SndBuf

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaFmt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PtyMaster

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockProtocol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SysInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IoVec<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dqblk

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'d> Debug for Iter<'d>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Errno

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Inotify

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlgSetAeadAuthSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpecialCharacterIndices

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ForkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlowArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UtsName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpKeepIdle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Whence

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SocketError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Options

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AlgSetKey<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DeleteModuleFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpliceFFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for LioCb<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OriginalDst

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReusePort

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ForkptyResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Entry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Linger

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpTransparent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for FcntlArg<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NetlinkAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VsockAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MapFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InetAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaValidFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleInitFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignalFd

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AioCancelStat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PosixFadviseAdvice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PeerCredentials

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InterfaceAddressIterator

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Termios

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InotifyEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CpuSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpAddMembership

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProtFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReceiveTimeout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlgAddr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlockArg

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenptyResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OobInline

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LioOpcode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MntFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMembershipRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Comparator

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Cmp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Syscall

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Action

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for scmp_arch

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for scmp_compare

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for scmp_filter_attr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for scmp_arg_cmp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MismatchedQuotes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CaptureLocations

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetMatches

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Regex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Shows the original regular expression.

impl Debug for RegexSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CaptureLocations

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Match<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Regex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Shows the original regular expression.

impl Debug for RegexSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Match<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetMatches

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MatchKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindOverlappingIter<'a, 'b, S> where
    S: 'a + StateID + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'s, 'h> Debug for FindIter<'s, 'h>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AhoCorasickBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, S> Debug for StreamFindIter<'a, R, S> where
    R: Debug,
    S: 'a + StateID + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for AhoCorasick<S> where
    S: StateID + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindIter<'a, 'b, S> where
    S: 'a + StateID + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Searcher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MatchKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Match

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassBytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Printer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassBytesRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpecialLiteralKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Class

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnicodeWordError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CaptureName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassPerl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassAsciiKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HexLiteralKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Group

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Assertion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Group

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Flag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicodeKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parser

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlagsItemKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Span

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParserBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ast

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassBracketed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WithComments

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Translator

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Flags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GroupKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AssertionKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParserBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicodeRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicodeOpKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Alternation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Comment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CaseFoldError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Hir

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassPerlKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Concat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TranslatorBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetUnion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GroupKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Printer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ClassBytesIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetBinaryOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetItem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassAscii

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Class

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Anchor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HirKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetBinaryOpKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Repetition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Repetition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parser

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Utf8Range

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ClassUnicodeIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Literals

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WordBoundary

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlagsItem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Utf8Sequence

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LiteralKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CachedThreadLocal<T> where
    T: Send + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ThreadLocal<T> where
    T: Send + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for IntoInnerError<W> where
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for BufStream<S> where
    S: Write + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CharacterSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for EncoderWriter<'a, W> where
    W: Write, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodeError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Name<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XmlEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OwnedAttribute

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TextPosition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EmitterConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OwnedName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParserConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EmitterError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XmlVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for XmlEvent<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NamespaceStack

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Attribute<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Namespace

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pixel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Analysis

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D> Debug for Hmac<D> where
    D: Input + BlockInput + FixedOutput + Reset + Default + Clone + Debug,
    <D as BlockInput>::BlockSize: ArrayLength<u8>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnpadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromHexError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SemVerError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReqParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Identifier

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VersionReq

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Op

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WildcardVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Predicate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VersionReq

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Identifier

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for List

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Domain

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DnsName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Host

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ByteSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignalType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for StyledValue<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Filter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Env<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Target

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimestampPrecision

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Logger

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Color

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WriteStyle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Style

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Formatter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Duration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FormattedDuration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Rfc3339Timestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timestamp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseColorError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorChoice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Color

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Md5

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EncodeConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PemError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LineEnding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha512Trunc224

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha384

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha512Trunc256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha512

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha224

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Keccak512

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha3_256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Keccak256Full

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha3_384

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Keccak384

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Keccak224

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha3_224

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shake128

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha3_512

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shake256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Keccak256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Loading content...

Implementors

impl Debug for sn0int::args::SubCommand

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for RuleType

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::add_cmd::Target

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Subcommand

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Format

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::keyring_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::mod_cmd::SubCommand

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AlternativeName

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for DbChange

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::db::Family

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::filters::Target

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::gfx::ImageFormat

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for LuaJsonValue

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Insert

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::models::Update

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for PslReader

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::shell::Command

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ReadlineError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReqBody

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for DatabaseEvent

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::worker::Event

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Event2

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ExitEvent

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for LogEvent

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for StdioEvent

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::args::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Completions

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Install

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Login

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for New

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Publish

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::args::Run

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Sandbox

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Search

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Autonoscope

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for DomainRule

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for IpRule

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewAutonoscope

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for RuleSet

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for UrlRule

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Blob

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddAccount

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddBreach

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddCryptoAddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddDevice

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddDomain

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddEmail

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddImage

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddIpAddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddNetblock

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddNetwork

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddPhoneNumber

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddSubdomain

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AddUrl

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::add_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Add

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::autonoscope_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Delete

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::delete_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::export_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::fsck_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for KeyRingAdd

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for KeyRingDelete

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for KeyRingGet

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for KeyRingList

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::mod_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::mod_cmd::List

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Reload

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Uninstall

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::mod_cmd::Update

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::noscope_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::quickstart_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::run_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::scope_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::select_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::set_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::target_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::use_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::cmd::workspace_cmd::Args

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::config::Config

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for CoreConfig

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NetworkConfig

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::crt::Certificate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::db::Filter

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Ttl

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Script

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for StartCommand

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for StdioReporter

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for DummyReporter

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Environment

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Module

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for LuaList

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for LuaMap

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::errors::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sn0int::filters::Filter

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AsnLookup

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::geoip::models::Continent

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::geoip::models::Country

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for GeoLookup

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::geoip::models::Location

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AsnDB

fn fmt(&self, w: &mut Formatter) -> Result

impl Debug for GeoIP

fn fmt(&self, w: &mut Formatter) -> Result

impl Debug for MaxmindReader

fn fmt(&self, w: &mut Formatter) -> Result

impl Debug for sn0int::gfx::exif::Location

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Element

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for KeyName

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for KeyRing

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for KeyRingEntry

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Account

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AccountUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Breach

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for BreachEmailUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for CryptoAddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for CryptoAddrUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Device

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for DeviceUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::models::Domain

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Email

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for EmailUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Image

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ImageUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertAccount

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertBreach

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertDevice

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertDomain

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertEmail

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertImage

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertIpAddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertNetblock

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertNetwork

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertPhoneNumber

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertPort

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertSubdomain

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for InsertUrl

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::models::IpAddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for IpAddrUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Netblock

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NetblockUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::models::Network

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NetworkDeviceUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NetworkUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewAccount

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewBreach

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewBreachEmail

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewCryptoAddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewDevice

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewDomain

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewEmail

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewImage

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewIpAddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewNetblock

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewNetwork

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewNetworkDevice

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewPhoneNumber

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewPort

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewSubdomain

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewSubdomainIpAddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for NewUrl

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for PhoneNumber

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for PhoneNumberUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::models::Port

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for PortUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Subdomain

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for SubdomainUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::models::Url

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for UrlUpdate

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Opt

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::psl::DnsName

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Psl

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Nudity

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ResolveOptions

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for birthday

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::accounts::columns::displayname

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for email

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::accounts::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::accounts::columns::last_seen

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for phonenumber

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for profile_pic

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::accounts::columns::service

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::accounts::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::accounts::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for url

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for username

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::accounts::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::accounts::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::autonoscope::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for object

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for scoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::autonoscope::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::autonoscope::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::autonoscope::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for breach_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for email_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::breach_emails::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for password

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::breach_emails::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::breach_emails::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::breaches::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::breaches::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::breaches::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::breaches::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::breaches::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for balance

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for currency

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for denominator

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::cryptoaddrs::columns::description

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for first_seen

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::cryptoaddrs::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for last_withdrawal

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for received

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::cryptoaddrs::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::cryptoaddrs::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::cryptoaddrs::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::cryptoaddrs::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for hostname

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::devices::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::devices::columns::last_seen

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::devices::columns::name

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::devices::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::devices::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::devices::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for vendor

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::devices::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::domains::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::domains::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::domains::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::domains::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::domains::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::emails::columns::displayname

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::emails::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::emails::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::emails::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::emails::columns::valid

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::emails::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::emails::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ahash

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for created

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for dhash

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for filename

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for height

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::images::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::images::columns::latitude

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::images::columns::longitude

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for mime

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for nudity

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for phash

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::images::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::images::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::images::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for width

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::images::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::as_org

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::asn

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for city

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for continent

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for continent_code

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::country

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for country_code

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::description

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::family

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::latitude

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::longitude

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for reverse_dns

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ipaddrs::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::columns::as_org

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::columns::asn

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::columns::description

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::columns::family

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::netblocks::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for device_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::network_devices::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ipaddr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::network_devices::columns::last_seen

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for network_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::network_devices::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::network_devices::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::networks::columns::description

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::networks::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::networks::columns::latitude

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::networks::columns::longitude

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::networks::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::networks::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::networks::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::networks::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for caller_name

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for caller_type

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for carrier

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::phonenumbers::columns::country

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::phonenumbers::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for is_ported

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for last_online

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for last_ported

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for line

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::phonenumbers::columns::name

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::phonenumbers::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::phonenumbers::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::phonenumbers::columns::valid

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::phonenumbers::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::phonenumbers::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for banner

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ports::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ip_addr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ports::columns::ip_addr_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for port

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for protocol

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ports::columns::service

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ports::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ports::columns::status

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ports::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ports::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for version

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ports::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomain_ipaddrs::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomain_ipaddrs::columns::ip_addr_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomain_ipaddrs::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomain_ipaddrs::columns::subdomain_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomain_ipaddrs::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for domain_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomains::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for resolvable

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomains::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomains::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomains::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::subdomains::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for expire

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ttls::columns::family

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ttls::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for key

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ttls::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::ttls::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for body

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::urls::columns::id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for online

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for path

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for redirect

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::urls::columns::star

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::urls::columns::status

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::urls::columns::subdomain_id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for title

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::urls::columns::unscoped

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::urls::columns::value

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::schema::urls::table

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for CmdCompleter

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for sn0int::sockets::Socket

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for SocketOptions

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for TlsData

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for AutoUpdater

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for CookieJar

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for HttpRequest

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for HttpSession

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for RequestOptions

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Resolver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for sn0int::web::Response

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EventSender

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for MultiEvent

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Workspace

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for XmlDocument

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for XmlElement

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for Params<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for Engine<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for ImageData<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<R> Debug for sn0int::web::Client<R> where
    R: DnsResolver + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T: Debug + IntoRule> Debug for Rule<T>

fn fmt(&self, f: &mut Formatter) -> Result

Loading content...