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

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

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Examples

Deriving an implementation:

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

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

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

Manually implementing:

use std::fmt;

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

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

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

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

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

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

Pretty-printing with #?:

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

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

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

Required methods

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

Formats the value using the given formatter.

Examples

use std::fmt;

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

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

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

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

Loading content...

Implementations on Foreign Types

impl Debug for StripPrefixError

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

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

impl Debug for SocketAddr

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

impl Debug for DirEntry

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

impl Debug for Initializer

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

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

impl Debug for Stdout

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

impl Debug for Sink

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

impl Debug for Error

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

impl Debug for SystemTime

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

impl<T> Debug for Key<T>

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

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

impl Debug for Output

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

impl Debug for RecvTimeoutError

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

impl Debug for FromBytesWithNulError

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

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

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

impl Debug for SeekFrom

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

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

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

impl<T> Debug for SendError<T>

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

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

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 AddrParseError

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

impl Debug for Path

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

impl Debug for Stdin

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<B> Debug for Lines<B> where
    B: Debug, 

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

impl Debug for OpenOptions

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 OnceState

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

impl Debug for ChildStdout

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

impl Debug for ThreadId

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

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

impl Debug for Instant

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

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

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

impl Debug for Empty

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

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

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

impl<T> Debug for TryLockError<T>

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

impl Debug for ChildStdin

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

impl Debug for Vars

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

impl Debug for File

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

impl Debug for IpAddr

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

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

impl Debug for SocketAddr

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

impl Debug for Args

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 ExitCode

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

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

impl Debug for RandomState

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

impl Debug for UnixListener

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

impl Debug for SocketAddrV4

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

impl Debug for IntoStringError

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

impl Debug for SystemTimeError

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 Condvar

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

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

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

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

impl Debug for TryRecvError

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

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

impl Debug for UnixDatagram

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

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

impl Debug for Barrier

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

impl Debug for WaitTimeoutResult

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<W> Debug for IntoInnerError<W> where
    W: Debug, 

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

impl Debug for Repeat

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

impl<T> Debug for SyncSender<T>

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 Metadata

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

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

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

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

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

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

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

impl Debug for BacktraceStatus

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 TcpListener

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

impl<T> Debug for Receiver<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 CString

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

impl Debug for ChildStderr

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

impl Debug for Ipv6Addr

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

impl Debug for Once

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<T> Debug for LocalKey<T> where
    T: 'static, 

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

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

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

impl Debug for VarError

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

impl Debug for AccessError

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

impl Debug for DirBuilder

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

impl<T> Debug for Key<T>

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

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

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

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

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

impl Debug for DefaultHasher

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

impl Debug for OsStr

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

impl Debug for Shutdown

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

impl<T> Debug for Sender<T>

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

impl Debug for FileType

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

impl Debug for Stderr

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 SocketAddrV6

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

impl Debug for Stdio

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

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 ArgsOs

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

impl Debug for Child

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

impl Debug for Backtrace

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

impl Debug for Thread

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

impl Debug for Builder

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

impl Debug for ExitStatus

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

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

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

impl Debug for Ipv4Addr

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

impl Debug for VarsOs

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

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

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

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

impl Debug for TcpStream

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

impl Debug for Ipv6MulticastScope

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

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

impl Debug for ErrorKind

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

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

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

impl Debug for Permissions

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

impl Debug for CStr

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

impl Debug for ReadDir

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

impl Debug for UnixStream

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

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

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

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

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<I, U> Debug for Flatten<I> where
    I: Debug + Iterator,
    U: Debug + Iterator,
    <I as Iterator>::Item: IntoIterator,
    <<I as Iterator>::Item as IntoIterator>::IntoIter == U,
    <<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item, 

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

impl<Ret, A> Debug for extern "C" fn(A) -> 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<'_, T> Debug for RefMut<'_, 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<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<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

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

impl<T> Debug for Discriminant<T>

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

impl Debug for NoneError

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 *const 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 VaListImpl<'f>

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

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

impl Debug for Ordering

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

impl Debug for TryFromSliceError

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

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

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

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

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

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

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

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

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

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

impl Debug for ParseFloatError

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

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

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

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

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

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

impl Debug for TryFromIntError

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

impl Debug for NonZeroI32

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

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

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

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

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

impl Debug for AtomicU8

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

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

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

impl Debug for EscapeDefault

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

impl Debug for __m256

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

impl Debug for ParseBoolError

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

impl Debug for NonZeroU32

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

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

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

impl Debug for __m512

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

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

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

impl Debug for ()

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

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

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

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

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

impl Debug for ToLowercase

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

impl Debug for AtomicU16

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

impl Debug for __m512d

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

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

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

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

impl Debug for f32

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

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

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

impl Debug for u32

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

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

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

impl Debug for LayoutErr

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 isize

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

impl Debug for c_void

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

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

impl Debug for CpuidResult

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

impl Debug for NonZeroU128

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

impl Debug for usize

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

impl Debug for NonZeroUsize

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, F> Debug for Map<I, F> where
    I: 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<I> Debug for DecodeUtf16<I> where
    I: Debug + Iterator<Item = u16>, 

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

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

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

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 AtomicIsize

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

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

impl Debug for u64

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

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

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

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

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

impl Debug for TypeId

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

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

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

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

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

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

impl Debug for Utf8Error

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

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

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 FpCategory

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

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

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

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

impl Debug for __m512i

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

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 Wrapping<T> where
    T: 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<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<'a> Debug for Bytes<'a>

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

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

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

impl Debug for str

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

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

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

impl Debug for AtomicI64

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

impl Debug for f64

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

impl Debug for !

fn fmt(&self, &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<Ret, A, B, C, D, E, F, G> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

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

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

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

impl Debug for i16

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

impl Debug for BorrowMutError

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

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

impl Debug for bool

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 AtomicI8

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

impl Debug for i8

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

impl<T> Debug for AtomicPtr<T>

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

impl Debug for char

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

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

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

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 EscapeDebug

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

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

impl Debug for u8

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

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

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

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

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

impl Debug for EscapeUnicode

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

impl Debug for NonZeroU64

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

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

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

impl Debug for __m256i

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

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

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

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

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

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

impl Debug for DecodeUtf16Error

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

impl Debug for AtomicBool

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

impl Debug for __m128i

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

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

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

impl Debug for NonZeroI128

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

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

impl Debug for UnicodeVersion

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<const N: usize, T> Debug for [T; N] where
    T: Debug,
    [T; N]: LengthAtMost32, 

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

impl Debug for i32

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

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

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

impl Debug for AtomicI32

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

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

impl Debug for PhantomPinned

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

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

impl Debug for SearchStep

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

impl<Ret, A, B, C, D, E, F, G, H, 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 __m128d

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

impl Debug for __m128

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

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

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

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

impl Debug for NonZeroIsize

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

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

impl Debug for NonZeroU16

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

impl Debug for NonZeroI64

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

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

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

impl Debug for Duration

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

impl Debug for EscapeDefault

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

impl<F> Debug for FromFn<F>

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

impl Debug for CharTryFromError

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, P> Debug for SplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

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

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

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

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

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

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

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

impl<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 Waker

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

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

impl Debug for AllocErr

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

impl<T> Debug for MaybeUninit<T>

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<const N: usize, T> Debug for IntoIter<T, N> where
    T: Debug,
    [T; N]: LengthAtMost32, 

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 AtomicUsize

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

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

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

impl<'a, 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 Ordering

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

impl<T> Debug for Empty<T>

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

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

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

impl Debug for u16

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

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

impl Debug for CannotReallocInPlace

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

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 __m256d

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

impl Debug for __m64

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

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

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

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

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

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

impl<'a, T> Debug for Chunks<'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, 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<Ret, A, B> Debug for fn(A, B) -> Ret

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, 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<T10, T11> Debug for (T10, T11) where
    T10: Debug,
    T11: Debug + ?Sized, 

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

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

impl Debug for RawWaker

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

impl Debug for u128

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

impl Debug for RangeFull

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

impl Debug for NonZeroI16

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

impl Debug for Utf8Lossy

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

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

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

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

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

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

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

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

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

impl Debug for ParseIntError

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

impl Debug for BorrowError

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

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

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

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

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

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

impl Debug for ParseCharError

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

impl Debug for i128

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

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

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

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<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<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<'_, F> Debug for CharPredicateSearcher<'_, F> where
    F: FnMut(char) -> bool, 

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

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

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

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

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 Debug for dyn Any + 'static + Send + Sync

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

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

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

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

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

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<'_, B> Debug for Cow<'_, B> where
    B: Debug + ToOwned + ?Sized,
    <B as ToOwned>::Owned: 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<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: 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 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<'a, T> Debug for DrainSorted<'a, T> where
    T: Ord + 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 FromUtf8Error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> Debug for BTreeSet<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 Range<'_, K, V> where
    K: Debug,
    V: Debug, 

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

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

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

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + 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<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

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

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

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

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

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

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

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

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

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

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

impl Debug for FromUtf16Error

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

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

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

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

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

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

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

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

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

impl<'a, T> Debug for Range<'a, T> where
    T: 'a + 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<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

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

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

impl Debug for _Unwind_Reason_Code

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

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

impl Debug for Frame

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

impl Debug for TryDemangleError

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

impl<'a> Debug for Demangle<'a>

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

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> Debug for RawOccupiedEntryMut<'_, 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> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: 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<'_, T, S> Debug for SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

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

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

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

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

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

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

impl<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> 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<'_, K, V, S> Debug for VacantEntry<'_, K, V, S> where
    K: 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 RustcEntry<'_, 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 Entry<'_, K, V, S> 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 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 Debug for Parsed

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

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 StrftimeItems<'a>

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

impl Debug for ParseError

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

impl Debug for Fixed

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 InternalNumeric

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

impl Debug for Weekday

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

impl Debug for FixedOffset

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 Pad

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 Utc

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

impl Debug for ParseWeekdayError

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

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

impl Debug for OutOfRangeError

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

impl Debug for Timespec

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

impl Debug for Duration

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

impl Debug for ParseError

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

impl Debug for Tm

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

impl Debug for SteadyTime

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

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

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 ParseFloatError

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

impl Debug for FloatErrorKind

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

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

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

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 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<'a, E> Debug for CowStrDeserializer<'a, 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 I16Deserializer<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 F32Deserializer<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 I32Deserializer<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<'de, E> Debug for BorrowedBytesDeserializer<'de, 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<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<E> Debug for StringDeserializer<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 UnitDeserializer<E> where
    E: Debug, 

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

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

impl Debug for SubmoduleStatus

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

impl Debug for ErrorClass

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

impl Debug for MergePreference

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

impl Debug for FileFavor

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

impl<'repo> Debug for Object<'repo>

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

impl<'a> Debug for DiffHunk<'a>

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

impl Debug for ReferenceType

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

impl<'repo> Debug for Commit<'repo>

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

impl Debug for Oid

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

impl Debug for MergeAnalysis

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

impl Debug for StashFlags

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

impl Debug for BranchType

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

impl Debug for AttrCheckFlags

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

impl Debug for DiffStats

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

impl Debug for RevparseMode

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

impl Debug for StashApplyFlags

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

impl Debug for IndexAddOption

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

impl<'rebase> Debug for RebaseOperation<'rebase>

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

impl Debug for RepositoryState

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

impl Debug for Status

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

impl<'repo> Debug for Note<'repo>

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

impl Debug for RepositoryOpenFlags

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

impl Debug for Error

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

impl Debug for Patch

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

impl Debug for ObjectType

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

impl<'repo> Debug for Tag<'repo>

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

impl Debug for StashApplyProgress

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

impl<'repo> Debug for OidArray

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

impl<'a> Debug for DiffLine<'a>

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

impl Debug for ConfigLevel

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

impl Debug for DiffBinaryKind

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

impl Debug for DiffStatsFormat

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

impl Debug for ErrorCode

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

impl Debug for Delta

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

impl Debug for IndexEntryFlag

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

impl Debug for CredentialType

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

impl<'a> Debug for DiffDelta<'a>

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

impl<'repo> Debug for Tree<'repo>

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

impl Debug for PathspecFlags

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

impl Debug for Sort

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

impl<'repo> Debug for Blob<'repo>

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

impl Debug for CheckoutNotificationType

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

impl Debug for RebaseOperationType

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

impl Debug for IndexEntryExtendedFlag

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

impl Debug for RepositoryInitMode

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

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

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

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

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

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

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

impl Debug for SetLoggerError

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

impl Debug for LevelFilter

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

impl Debug for Level

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 ParseLevelError

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

impl Debug for Origin

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

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

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

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

impl Debug for Position

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

impl<'a> Debug for UrlQuery<'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 Url

Debug the serialization of this URL.

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

impl Debug for SyntaxViolation

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

impl Debug for OpaqueOrigin

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

impl Debug for Errors

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

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

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

impl Debug for BidiClass

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

impl Debug for ParagraphInfo

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

impl Debug for Level

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 Error

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

impl Debug for IsNormalized

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 SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

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

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

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

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

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

impl Debug for Error

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

impl Debug for Value

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

impl Debug for Error

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

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

impl Debug for Confidentiality

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

impl Debug for PrivilegesRequired

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

impl Debug for Score

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

impl Debug for UserInteraction

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

impl Debug for ErrorKind

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

impl Debug for Availability

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

impl Debug for Integrity

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

impl Debug for AttackComplexity

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

impl Debug for Base

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

impl Debug for Error

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

impl Debug for AttackVector

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

impl Debug for Scope

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 ReqParseError

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

impl Debug for SemVerError

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

impl Debug for Op

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

impl Debug for Identifier

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

impl Debug for Version

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 WildcardVersion

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

impl Debug for WildcardVersion

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

impl<'input> Debug for Token<'input>

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

impl Debug for Comparator

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

impl Debug for Predicate

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

impl Debug for Op

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

impl Debug for Version

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

impl Debug for Error

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

impl<'input> Debug for Error<'input>

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

impl Debug for VersionReq

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

impl<'input> Debug for Lexer<'input>

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

impl Debug for Identifier

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

impl Debug for Error

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

impl Debug for Value

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

impl Debug for ErrorKind

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

impl Debug for Tree

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

impl Debug for Key

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

impl Debug for Dependency

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

impl Debug for Patch

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

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

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

impl Debug for Config

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

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

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

impl Debug for Time

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

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

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

impl Debug for Undirected

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Directed

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for NegativeCycle

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

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

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

impl Debug for EdgesNotSorted

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Direction

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

impl Debug for FixedBitSet

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, K, V> Debug for Iter<'a, K, V> where
    K: Debug,
    V: 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<'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, 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<T> Debug for IntoIter<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<'a, T> Debug for Iter<'a, T> where
    T: 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, T, S> Debug for Intersection<'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 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 Values<'a, K, V> where
    V: 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 Debug for Env

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

impl Debug for Tier

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

impl Debug for Platform

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

impl Debug for Error

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

impl Debug for OS

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

impl Debug for Arch

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

impl Debug for PlatformReq

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

impl Debug for Manifest

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

impl Debug for Dependency

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

impl Debug for ErrorKind

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

impl<'a> Debug for CrateName<'a>

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

impl Debug for Error

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

impl Debug for LocalManifest

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

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 BacktraceSymbol

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

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

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 Item

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

impl Debug for Key

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

impl Debug for InlineTable

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

impl Debug for Table

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

impl Debug for Document

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

impl Debug for Array

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

impl Debug for ArrayOfTables

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

impl Debug for Value

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

impl Debug for TomlError

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

impl Debug for UnexpectedParse

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

impl<T, R> Debug for Error<T, R> where
    R: Debug,
    T: Debug, 

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

impl Debug for TakeRange

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

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

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

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

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

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

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

impl Debug for IndexPositioner

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

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

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

impl<T, R> Debug for Info<T, R> where
    R: Debug,
    T: Debug, 

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

impl<I, X> Debug for State<I, X> where
    I: Debug,
    X: Debug, 

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

impl<I> Debug for BufferedStream<I> where
    I: Debug + StreamOnce + Positioned,
    <I as StreamOnce>::Item: Debug,
    <I as StreamOnce>::Position: Debug, 

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

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

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

impl<T, R> Debug for Info<T, R> where
    R: Debug,
    T: Debug, 

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

impl Debug for PointerOffset

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

impl Debug for SourcePosition

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

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

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

impl Debug for StringStreamError

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

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

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

impl<I, R, P> Debug for Errors<I, R, P> where
    I: Debug,
    P: Debug,
    R: Debug, 

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

impl Debug for BigEndian

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

impl Debug for LittleEndian

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

impl<L, R> Debug for Either<L, R> where
    L: Debug,
    R: Debug, 

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

impl Debug for Void

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

impl Debug for AsciiChar

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

impl Debug for AsciiString

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

impl Debug for AsciiStr

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

impl Debug for ToAsciiCharError

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

impl<O> Debug for FromAsciiError<O>

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

impl Debug for AsAsciiStrError

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

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

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

impl<A, B, S> Debug for LinkedHashMap<A, B, S> where
    A: Eq + Debug + Hash,
    B: Debug,
    S: BuildHasher, 

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

Returns a string that lists the key-value pairs in insertion order.

impl<'t> Debug for Captures<'t>

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

impl Debug for CaptureLocations

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

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 CaptureLocations

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

impl Debug for SetMatches

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 RegexSet

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, 'h> Debug for FindIter<'s, 'h>

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<'a, 'b, S> Debug for FindOverlappingIter<'a, 'b, S> where
    S: 'a + 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 Config

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

impl Debug for ErrorKind

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

impl Debug for Searcher

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

impl Debug for MatchKind

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

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

impl Debug for Builder

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

impl Debug for ClassUnicodeRange

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

impl Debug for RepetitionKind

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

impl Debug for HirKind

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

impl Debug for ClassSetUnion

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

impl Debug for SetFlags

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

impl Debug for LiteralKind

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

impl Debug for Printer

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

impl Debug for Literal

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

impl Debug for RepetitionRange

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

impl Debug for ClassSetRange

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

impl Debug for ParserBuilder

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 CaptureName

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

impl Debug for Concat

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 ClassSetItem

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

impl Debug for Utf8Range

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

impl Debug for ClassSet

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

impl Debug for ClassAsciiKind

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

impl Debug for Repetition

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 ClassUnicodeKind

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

impl Debug for RepetitionRange

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

impl Debug for Literal

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

impl Debug for FlagsItemKind

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

impl Debug for FlagsItem

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

impl Debug for Printer

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

impl Debug for Class

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

impl Debug for ClassUnicodeOpKind

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

impl Debug for Flags

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

impl Debug for ClassUnicode

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

impl Debug for Anchor

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

impl Debug for ParserBuilder

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

impl Debug for Group

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

impl Debug for WordBoundary

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

impl Debug for Repetition

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

impl Debug for ErrorKind

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

impl Debug for AssertionKind

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

impl Debug for Class

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

impl Debug for Comment

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

impl Debug for Assertion

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

impl Debug for Parser

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

impl Debug for Position

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

impl Debug for Span

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

impl Debug for RepetitionOp

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

impl Debug for Flag

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

impl Debug for ClassSetBinaryOpKind

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

impl Debug for TranslatorBuilder

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

impl Debug for ClassBytes

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

impl Debug for Utf8Sequence

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

impl Debug for ClassPerlKind

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

impl Debug for Parser

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

impl Debug for UnicodeWordError

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

impl Debug for WithComments

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

impl Debug for ClassUnicode

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

impl Debug for Translator

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

impl Debug for ClassSetBinaryOp

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

impl Debug for CaseFoldError

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

impl Debug for GroupKind

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

impl Debug for ClassBracketed

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

impl Debug for Error

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

impl Debug for Literal

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

impl Debug for RepetitionKind

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

impl Debug for ClassPerl

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

impl Debug for ClassBytesRange

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

impl Debug for Group

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

impl Debug for Ast

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

impl Debug for GroupKind

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

impl Debug for Literals

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

impl Debug for Alternation

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

impl Debug for ClassAscii

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 HexLiteralKind

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

impl Debug for SpecialLiteralKind

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

impl<T> Debug for ThreadLocal<T> where
    T: Send + Debug, 

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

impl<T> Debug for CachedThreadLocal<T> where
    T: Send + Debug, 

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

impl Debug for RequestBuilder

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

impl Debug for ClientBuilder

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

impl Debug for Policy

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

impl Debug for Body

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

impl Debug for Body

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

impl Debug for Client

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

impl Debug for Identity

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

impl Debug for Request

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

impl Debug for Proxy

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

impl Debug for Certificate

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

impl Debug for Request

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

impl Debug for Response

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

impl Debug for Part

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

impl Debug for RequestBuilder

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

impl Debug for ClientBuilder

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

impl Debug for Part

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

impl Debug for Error

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

impl Debug for Action

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

impl Debug for Response

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

impl Debug for Form

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

impl<'a> Debug for Attempt<'a>

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

impl Debug for Form

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

impl Debug for Client

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

impl<'a, T> Debug for Keys<'a, T> where
    T: Debug, 

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

impl Debug for Extensions

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

impl Debug for InvalidStatusCode

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

impl Debug for InvalidUri

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

impl Debug for Parts

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

impl Debug for InvalidMethod

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 ToStrError

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

impl<'a, T> Debug for ValueDrain<'a, T> where
    T: Debug, 

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

impl Debug for Scheme

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 Drain<'a, T> where
    T: Debug, 

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

impl<'a, T> Debug for ValuesMut<'a, T> where
    T: Debug, 

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

impl Debug for InvalidHeaderValue

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

impl<'a, T> Debug for Values<'a, T> where
    T: Debug, 

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

impl Debug for Builder

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

impl Debug for Builder

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

impl Debug for HeaderName

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

impl<'a, T> Debug for IterMut<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PathAndQuery

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Uri

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<'a, T> Debug for GetAll<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StatusCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ValueIterMut<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for OccupiedEntry<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parts

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ValueIter<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Authority

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parts

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HeaderValue

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 InvalidHeaderName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidUriParts

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Response<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

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<'a, T> Debug for Iter<'a, 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 Debug for Bytes

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<T> Debug for Take<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for Writer<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BytesMut

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Limit<T> where
    T: 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 IoSliceMut<'_>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AtomicWaker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AbortRegistration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for Then<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for MapErr<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Iter<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Chunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for Close<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for IntoStream<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Fuse<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AllowStdIo<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for NeverError<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, S, Fut, F> Debug for Scan<St, S, Fut, F> where
    Fut: Debug,
    S: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for Write<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for WriteAll<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadToString<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Empty<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for Select<St1, St2> where
    St1: Debug,
    St2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, E> Debug for ErrInto<Fut, E> where
    E: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for Map<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Once<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Fuse<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Abortable<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for SelectNextSome<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for Join5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    Fut5: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug,
    <Fut5 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Skip<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for InspectErr<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for TrySelect<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for MapOk<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for MapErr<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for Filter<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for InspectOk<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Repeat<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for Next<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for Inspect<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for WriteVectored<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for CatchUnwind<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for Seek<'a, S> where
    S: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Concat<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Flatten<Fut> where
    Fut: Future + Debug,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for Lazy<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Shared<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for IntoStream<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for StreamFuture<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for OrElse<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2> Debug for TryJoin<Fut1, Fut2> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Take<St> where
    St: 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<Fut, F> Debug for MapOk<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2> Debug for Join<Fut1, Fut2> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Enumerate<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadToEnd<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, W> Debug for Copy<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FuturesUnordered<Fut>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for OptionFuture<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for SkipWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for Zip<St1, St2> where
    St1: Debug + Stream,
    St2: Debug + Stream,
    <St1 as Stream>::Item: Debug,
    <St2 as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for BufferUnordered<St> where
    St: Stream + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Buffered<St> where
    St: Stream + Debug,
    <St as Stream>::Item: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, St> Debug for Peek<'_, St> where
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FlattenStream<Fut> where
    Fut: Future + Debug,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for TryJoin4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for OrElse<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Repeat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryFlatten<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for UnitError<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilter<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, C> Debug for Collect<St, C> where
    C: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for PollFn<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for Map<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for JoinAll<F> where
    F: Future + Debug,
    <F as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for InspectErr<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinMut<'a, Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for SelectOk<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for Chain<St1, St2> where
    St1: Debug,
    St2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadExact<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, W> Debug for CopyBuf<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for InspectOk<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sink

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadLine<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Flatten<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Lines<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FuturesOrdered<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, U> Debug for MappedMutexGuard<'_, T, U> where
    T: ?Sized,
    U: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for MutexGuard<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for Join4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryBufferUnordered<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadUntil<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, E> Debug for ErrInto<St, E> where
    E: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Take<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TakeWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for FilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for TryFlattenStream<Fut> where
    Fut: TryFuture + Debug,
    <Fut as TryFuture>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for IntoFuture<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for IterMut<'a, Fut> where
    Fut: Unpin + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryConcat<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for IntoAsyncRead<St> where
    St: Debug + TryStream<Error = Error> + Unpin,
    <St as TryStream>::Ok: AsRef<[u8]>,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for UnwrapOrElse<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for TryJoin3<Fut1, Fut2, Fut3> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, C> Debug for TryCollect<St, C> where
    C: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinRef<'a, Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for SelectAll<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TrySkipWhile<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Ready<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for CatchUnwind<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for Join3<Fut1, Fut2, Fut3> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for TryJoin5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    Fut5: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug,
    <Fut5 as TryFuture>::Ok: Debug,
    <Fut5 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for TryNext<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for Flush<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for Then<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, T, F> Debug for Fold<St, Fut, T, F> where
    Fut: Debug,
    St: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Select<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for TryJoinAll<F> where
    F: TryFuture + Debug,
    <F as TryFuture>::Ok: Debug,
    <F as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for AndThen<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for MaybeDone<Fut> where
    Fut: Debug + Future,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadVectored<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Peekable<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, T, F> Debug for TryFold<St, Fut, T, F> where
    Fut: Debug,
    St: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AbortHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, Fut> Debug for TryUnfold<T, F, Fut> where
    Fut: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for MutexLockFuture<'_, T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for Inspect<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    Fut: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for SelectAll<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for AndThen<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for Read<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for WriteHalf<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<'a, Fut> Debug for Iter<'a, Fut> where
    Fut: Unpin + 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<T> Debug for Cursor<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Aborted

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for PollFn<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpawnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for WakerRef<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for LocalFutureObj<'_, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for FutureObj<'_, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

fn fmt(&self, fmt: &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 Drain<'a, T> where
    T: 'a, 

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 Iter<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Data<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Trailers<'a, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SizeHint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Repeat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Lines<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Sink

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BarrierWaitResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Key

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryRecvError

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 Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for Seek<'a, S> where
    S: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for MutexGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Semaphore

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

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 Receiver<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryCurrentError

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 TrySendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SemaphorePermit<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Elapsed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Delay

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Empty

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for WriteHalf<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RwLock<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Incoming<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Interval

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for JoinHandle<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for RwLockWriteGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClosedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<RW> Debug for BufStream<RW> where
    RW: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Barrier

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<'a, R, W> Debug for Copy<'a, R, W> where
    R: Debug + ?Sized,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Registration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Runtime

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<'a, T> Debug for Ref<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Split<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Instant

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for RwLockReadGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ReadHalf<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

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<T> Debug for UnboundedReceiver<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Take<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for JoinError

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for PollOpt

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Events

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UdpSocket

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Registration

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Iter<'a>

fn fmt(&self, f: &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 SetReadiness

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Token

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixReady

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Poll

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Ready

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for TcpBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UdpBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

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<T> Debug for Parts<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Connected

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<I, S> Debug for Connection<I, S, Exec> where
    S: HttpService<Body>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Body

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Name

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<C, B, T> Debug for Connect<C, B, T> where
    B: Debug,
    C: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddrStream

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 Debug for GaiAddrs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sender

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 Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OnUpgrade

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 Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseFuture

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>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddrIncoming

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 Debug for GaiResolver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HttpInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidNameError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Upgraded

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GaiFuture

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<T> Debug for Parts<T> where
    T: Debug, 

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<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<T> Debug for Receiver<T> where
    T: 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 Debug for Canceled

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

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 UnboundedReceiver<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 StreamId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for ReadySendRequest<B> where
    B: Debug + Buf, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PushPromise

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlowControl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendStream<B> where
    B: Debug + Buf, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B> where
    B: Debug + Buf,
    T: AsyncRead + AsyncWrite + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendResponse<B> where
    B: Debug + Buf, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvStream

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for PushPromises

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Debug + Buf,
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Ping

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for PingPong

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendPushedResponse<B> where
    B: Debug + Buf, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Reason

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PushedResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Debug + Buf,
    T: AsyncRead + AsyncWrite + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendRequest<B> where
    B: Buf, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Pong

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LengthDelimitedCodecError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LengthDelimitedCodec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BytesCodec

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, U> Debug for FramedParts<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

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 Debug for LinesCodec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LinesCodecError

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 Debug for SharedGiver

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 Giver

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 TryLock<T> where
    T: 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<'headers, 'buf> Debug for Request<'headers, 'buf> where
    'buf: 'headers, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidChunkSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Status<T> where
    T: Debug, 

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 Protocol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for HandshakeError<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for TlsStream<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for MidHandshakeTlsStream<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SslContext

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Ssl

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for MidHandshakeSslStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for SslStream<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorStack

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OcspCertStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlpnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SrtpProfileId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpensslString

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for KeyIvPair

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CMSOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ShutdownState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pkcs7Flags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslRef

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for HandshakeError<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExtensionContext

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpensslStringRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for X509VerifyResult

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SslOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for EcKey<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ShutdownResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for X509CheckFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslVerifyMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimeDiff

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigNum

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Dsa<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Nid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OcspRevokedStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DigestBytes

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SslAlert

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rsa<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OcspFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClientHelloResponse

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SniError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OcspResponseStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Padding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigNumRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslSessionCacheMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Id

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MimeGuess

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Iter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IterRaw

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromStrError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Params<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Name<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for UniCase<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Ascii<S> where
    S: Debug, 

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 Debug for CharacterSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Encoding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EncoderResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecoderResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Latin1Bidi

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CoderResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TlsAcceptor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TlsConnector

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for TlsStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for HttpsConnector<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for HttpsConnecting<T>

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 Debug for ParseColorError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Color

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorChoice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ColorSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Stream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pipeline

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NullFile

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PopenError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Popen

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PopenConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExitStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Redirection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Map<String, Value>

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Category

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Number

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for CompactFormatter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromHexError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Crate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dependency

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Index

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 PatternError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlobError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pattern

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Loading content...

Implementors

impl Debug for rustsec::advisory::category::Category

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Severity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rustsec::advisory::id::Kind

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Informational

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::advisory::linter::ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Collection

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for PackageSource

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::error::ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ResolveVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Alignment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Checksum

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GitReference

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rustsec::warning::Kind

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Affected

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for FunctionPath

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::advisory::affected::Identifier

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::advisory::date::Date

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::advisory::id::Id

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Keyword

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::advisory::linter::Error

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Linter

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::advisory::metadata::Metadata

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Advisory

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Versions

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for PackageScope

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Database

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Query

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::error::Error

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Lockfile

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rustsec::package::checksum::fmt::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rustsec::package::Name

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Package

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SourceId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for rustsec::package::Version

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DatabaseInfo

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for LockfileInfo

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Report

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Settings

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for VulnerabilityInfo

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::repository::commit::Commit

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::VersionReq

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for rustsec::version::Version

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Vulnerability

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Warning

fn fmt(&self, f: &mut Formatter) -> Result

impl<'_> Debug for Arguments<'_>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

Loading content...