Trait frame_support::dispatch::fmt::Debug

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

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Stability

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

Examples

Deriving an implementation:

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

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

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

Manually implementing:

use std::fmt;

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

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

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

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

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

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

Pretty-printing with #?:

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

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

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

Required methods

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

Formats the value using the given formatter.

Examples

use std::fmt;

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

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

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

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

Loading content...

Implementations on Foreign Types

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

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

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

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

impl Debug for OsString

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

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

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

impl Debug for Path

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

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

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

impl Debug for UdpSocket

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

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

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

impl Debug for Output

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

impl<T> Debug for Receiver<T>

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

impl Debug for ReadDir

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

impl Debug for StripPrefixError

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

impl Debug for Command

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

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

impl Debug for ArgsOs

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

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

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

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

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

impl Debug for AddrParseError

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

impl Debug for FromBytesWithNulError

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

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

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

impl Debug for ThreadId

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

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

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

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

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

impl<T> Debug for SyncSender<T>

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

impl Debug for AccessError

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

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

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

impl Debug for ChildStdin

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

impl Debug for Barrier

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

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

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

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

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

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

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

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

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

impl Debug for DirBuilder

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

impl Debug for DefaultHasher

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

impl<T> Debug for TrySendError<T>

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

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

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

impl<T> Debug for Key<T>

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

impl Debug for BacktraceFrame

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

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

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

impl<T> Debug for PoisonError<T>

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

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

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

impl Debug for TcpListener

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

impl Debug for Ipv6Addr

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

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

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

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

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

impl Debug for NulError

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

impl Debug for Stdout

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

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

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

impl Debug for TcpStream

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

impl Debug for TryRecvError

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

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

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

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

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

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

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

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

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

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

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

impl<T> Debug for JoinHandle<T>

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

impl Debug for Backtrace

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

impl Debug for Child

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

impl Debug for BarrierWaitResult

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

impl Debug for Initializer

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

impl Debug for VarError

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

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

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

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

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

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

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

impl Debug for CString

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

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

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

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

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

impl Debug for Ipv6MulticastScope

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

impl Debug for IntoStringError

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

impl Debug for SocketAddr

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

impl<T> Debug for TryLockError<T>

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

impl Debug for SocketAddr

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

impl Debug for Error

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

impl Debug for SeekFrom

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

impl Debug for Sink

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

impl Debug for ExitStatus

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

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

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

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

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

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

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

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

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

impl Debug for ChildStdout

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

impl Debug for OnceState

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

impl Debug for UCred

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

impl Debug for Stdin

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

impl Debug for System

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

impl Debug for ExitCode

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

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

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

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

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

impl Debug for Builder

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

impl Debug for Permissions

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

impl Debug for RecvError

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

impl Debug for Condvar

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

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

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

impl<T> Debug for SendError<T>

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

impl Debug for Stdio

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

impl Debug for CStr

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

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

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

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

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

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

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

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

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

impl Debug for Vars

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

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

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

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

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

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

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

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

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

impl Debug for RecvTimeoutError

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

impl Debug for SocketAddrV6

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

impl Debug for RandomState

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

impl Debug for SystemTime

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

impl Debug for JoinPathsError

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

impl Debug for UnixDatagram

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

impl Debug for Stderr

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

impl Debug for SocketAddrV4

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

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

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

impl Debug for UnixListener

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

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

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

impl<T> Debug for Sender<T>

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

impl Debug for OsStr

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

impl Debug for OpenOptions

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

impl Debug for Empty

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

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

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

impl Debug for Args

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

impl Debug for Thread

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

impl Debug for FromVecWithNulError

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

impl Debug for Metadata

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

impl Debug for UnixStream

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

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

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

impl<T> Debug for Key<T>

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

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

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

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

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

impl Debug for Once

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

impl Debug for ErrorKind

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

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

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

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

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

impl Debug for IpAddr

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

impl Debug for Instant

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

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

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

impl Debug for Shutdown

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

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

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

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

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

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

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

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

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

impl Debug for SystemTimeError

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

impl Debug for DirEntry

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

impl Debug for BacktraceStatus

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

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

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

impl Debug for ChildStderr

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

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

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

impl Debug for Ipv4Addr

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

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

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

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

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

impl Debug for WaitTimeoutResult

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

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

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

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

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

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

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

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

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

impl Debug for File

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

impl Debug for PathBuf

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

impl Debug for FileType

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

impl Debug for AncillaryError

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

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

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

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

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

impl Debug for VarsOs

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

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

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

impl Debug for Repeat

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

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

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

impl Debug for RawWakerVTable

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

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

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

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

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

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

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

impl Debug for Infallible

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

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

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

impl Debug for __m512

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

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

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

impl Debug for ()

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

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

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

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

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

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

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

impl Debug for AtomicU8

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

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

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

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

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

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

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

impl Debug for RawWaker

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

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

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

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

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

impl<T> Debug for Discriminant<T>

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

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

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

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

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

impl Debug for EscapeUnicode

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

impl Debug for SearchStep

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroI16

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

impl Debug for BorrowMutError

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

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

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroU64

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

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

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

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

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

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

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

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

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

impl Debug for DecodeUtf16Error

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

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

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

impl Debug for __m256i

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroI32

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

impl Debug for f64

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

impl Debug for u8

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

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

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

impl Debug for i16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicIsize

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

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

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

impl Debug for TypeId

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

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

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

impl Debug for AtomicU16

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

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

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

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

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

impl Debug for NonZeroI8

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

impl Debug for LayoutError

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

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

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

impl Debug for AtomicI64

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

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

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

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

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

impl Debug for NonZeroU8

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

impl Debug for NonZeroU16

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

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

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

impl Debug for ToLowercase

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

impl Debug for usize

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

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

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

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

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

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

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

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

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

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

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

impl Debug for __m512d

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

impl Debug for u64

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

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

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

impl Debug for u32

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

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

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

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

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

impl Debug for AtomicI32

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

impl Debug for NonZeroU32

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

impl Debug for AtomicUsize

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

impl Debug for IntErrorKind

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for __m256d

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

impl Debug for __m256

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

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

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

impl Debug for BorrowError

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

impl Debug for i32

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

impl<T> Debug for Pending<T>

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

impl<F> Debug for PollFn<F>

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

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

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

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

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

impl Debug for AtomicU32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for RangeFull

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Duration

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

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

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

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

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

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

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

impl Debug for u16

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

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

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

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

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

impl Debug for TryFromIntError

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

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

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

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

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

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

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

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

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

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

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

impl Debug for u128

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

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

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

impl Debug for EscapeDebug

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

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

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

impl Debug for NonZeroI64

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

impl Debug for ParseIntError

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

impl Debug for NonZeroUsize

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

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

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

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

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

impl<F> Debug for FromFn<F>

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

impl Debug for ParseCharError

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

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

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

impl<H> Debug for BuildHasherDefault<H>

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

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

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

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

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

impl Debug for c_void

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

impl Debug for dyn Any + 'static

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

impl Debug for FpCategory

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

impl Debug for AtomicI8

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

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

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

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

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

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

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

impl Debug for str

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

impl Debug for i64

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Waker

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

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

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

impl Debug for Utf8Lossy

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

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

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

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

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

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

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

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

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

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

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

impl Debug for ParseBoolError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Layout

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for EscapeDefault

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

impl Debug for ToUppercase

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

impl Debug for __m128d

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

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

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

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

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

impl Debug for NonZeroIsize

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

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

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

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

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

impl Debug for f32

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

impl Debug for Utf8Error

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicU64

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

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

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

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

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

impl Debug for ParseFloatError

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

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

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

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

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

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

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

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

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

impl Debug for TryFromSliceError

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

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

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

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

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

impl Debug for i8

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

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

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

impl Debug for __m128i

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

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

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

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

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

impl Debug for AtomicI16

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

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

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

impl Debug for NonZeroU128

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

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

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

impl Debug for EscapeDefault

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

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

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

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

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

impl Debug for AtomicBool

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

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

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

impl Debug for __m128

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Ordering

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

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

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

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

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

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

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

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

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

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

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

impl Debug for AllocError

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

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

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

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

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

impl Debug for isize

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

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

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

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

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

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

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

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

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

impl<T> Debug for AtomicPtr<T>

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

impl Debug for Ordering

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

impl<T> Debug for MaybeUninit<T>

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

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

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

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

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

impl Debug for NoneError

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

impl Debug for bool

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

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

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

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

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

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

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

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

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

impl Debug for dyn Any + 'static + Send

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

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

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

impl<T> Debug for Empty<T>

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

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

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

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

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

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

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

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

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

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

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

impl Debug for char

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

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

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

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

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

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

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

impl Debug for !

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

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

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

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

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

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

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

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

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

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

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

impl Debug for __m512i

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

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

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

impl Debug for CharTryFromError

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

impl Debug for i128

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

impl Debug for CpuidResult

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

impl Debug for NonZeroI128

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

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

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

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

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

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

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

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

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

impl Debug for SipHasher

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TryReserveError

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

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

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

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

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

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

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, F> Debug for DrainFilter<'_, T, F> where
    T: Debug,
    F: FnMut(&T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Entry<'_, K, V> where
    K: Debug + Ord,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for RangeMut<'_, K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for OccupiedEntry<'_, K, V> where
    K: Debug + Ord,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for BTreeMap<K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for CursorMut<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromUtf8Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, K, V> Debug for IterMut<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for OccupiedError<'_, K, V> where
    K: Debug + Ord,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, F> Debug for DrainFilter<'_, T, F> where
    T: Debug,
    F: FnMut(&mut T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for BTreeSet<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoKeys<K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Rc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Union<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for String

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Difference<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, F, A> Debug for DrainFilter<'a, T, F, A> where
    T: Debug,
    A: Debug + Allocator,
    F: Debug + FnMut(&mut T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for IntoIter<T, A> where
    T: Debug,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for DrainSorted<'a, T> where
    T: Debug + Ord, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, A> Debug for Drain<'_, T, A> where
    T: Debug,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Drain<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, B> Debug for Cow<'_, B> where
    B: Debug + ToOwned + ?Sized,
    <B as ToOwned>::Owned: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Global

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromUtf16Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Range<'_, K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for Box<T, A> where
    T: Debug + ?Sized,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Cursor<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Debug + Ord, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIterSorted<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Iter<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for Intersection<'_, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LinkedList<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for _Unwind_Reason_Code

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WasmMetadata

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WasmLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WasmEntryAttributes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WasmValue

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WasmFieldName

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WasmFields

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WasmValuesSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Compact<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OptionBool

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, const CAP: usize> Debug for IntoIter<T, CAP> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, const CAP: usize> Debug for ArrayVec<T, CAP> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CapacityError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<const CAP: usize> Debug for ArrayString<CAP>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I128Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for BytesDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U128Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IgnoredAny

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    I: Debug, 

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Field

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ValueSet<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Record<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for dyn Value + 'static

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Iter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DefaultGuard

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Current

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Identifier

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Id

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LevelFilter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelFilterError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetGlobalDefaultError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugValue<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Interest

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DisplayValue<T> where
    T: Display, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Dispatch

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FieldSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Attributes<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Level

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Event<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Kind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EnteredSpan

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Instrumented<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for WithDispatch<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Span

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Entered<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for DefaultVisitor<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FormattedFields<E>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Full

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BadName

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CurrentSpan

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Directive

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EnvFilter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, L> Debug for Scope<'a, L> where
    L: LookupSpan<'a>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<L, S> Debug for Layer<L, S> where
    S: Debug,
    L: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for Parents<'a, R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pretty

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for JsonVisitor<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for Context<'a, S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, E, F, W> Debug for SubscriberBuilder<N, E, F, W> where
    F: Debug,
    E: Debug,
    N: Debug,
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, N, E, W> Debug for Layer<S, N, E, W> where
    E: Debug,
    S: Debug,
    N: Debug,
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Extensions<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D, V> Debug for VisitDelimited<D, V> where
    V: Debug,
    D: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<V> Debug for Alt<V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Identity

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Registry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<L, S> Debug for Handle<L, S> where
    S: Debug,
    L: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BoxMakeWriter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D, V> Debug for Delimited<D, V> where
    V: Debug,
    D: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Data<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FmtSpan

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, F> Debug for FieldFnVisitor<'a, F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SystemTime

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChronoLocal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'span, R> Debug for FromRoot<'span, R> where
    R: LookupSpan<'span>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PrettyVisitor<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TestWriter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromEnvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for SpanRef<'a, R> where
    R: Debug + LookupSpan<'a>,
    <R as LookupSpan<'a>>::Data: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<V> Debug for Messages<V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<L, I, S> Debug for Layered<L, I, S> where
    I: Debug,
    S: Debug,
    L: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ExtensionsMut<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChronoUtc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PrettyFields

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DefaultFields

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for JsonFields

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Uptime

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Json

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F, T> Debug for Format<F, T> where
    T: Debug,
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<N, E, F, W> Debug for Subscriber<N, E, F, W> where
    F: Debug,
    E: Debug,
    N: Debug,
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Compact

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryInitError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S, N> Debug for FmtContext<'a, S, N>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for FieldFn<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatches

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for NoExpand<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c, 't> Debug for SubCaptureMatches<'c, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SetMatchesIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'c, 't> Debug for SubCaptureMatches<'c, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for CaptureMatches<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Matches<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureLocations

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Match<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for SplitN<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for NoExpand<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Regex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Shows the original regular expression.

impl Debug for RegexBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for Match<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatchesIntoIter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSetBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for CaptureNames<'r>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatches

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for CaptureMatches<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SetMatchesIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Split<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureLocations

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r> Debug for CaptureNames<'r>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSetBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for SplitN<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Split<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'r, 't> Debug for Matches<'r, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Regex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Shows the original regular expression.

impl Debug for RegexBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetMatchesIntoIter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Group

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AssertionKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Position

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaseFoldError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TranslatorBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBytesRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBytes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassBracketed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassAsciiKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literals

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassPerl

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Class

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Sequence

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HexLiteralKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetBinaryOpKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassAscii

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Assertion

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repetition

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FlagsItemKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Anchor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Range

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Flag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetBinaryOp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Concat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetItem

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parser

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnicodeWordError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LiteralKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassPerlKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CaptureName

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Alternation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Printer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GroupKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpecialLiteralKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ClassUnicodeIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Translator

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WithComments

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Group

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Hir

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FlagsItem

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Comment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WordBoundary

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HirKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for ClassBytesIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repetition

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Flags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Class

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Literal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utf8Sequences

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeOpKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GroupKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionOp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RepetitionRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParserBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ast

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassSetUnion

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Span

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Printer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parser

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ClassUnicodeKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for AhoCorasick<S> where
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Searcher

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, S> Debug for StreamFindIter<'a, R, S> where
    R: Debug,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindIter<'a, 'b, S> where
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Match

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s, 'h> Debug for FindIter<'s, 'h>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MatchKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AhoCorasickBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindOverlappingIter<'a, 'b, S> where
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Config

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MatchKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'h, 'n> Debug for FindRevIter<'h, 'n>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'h, 'n> Debug for FindIter<'h, 'n>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Prefilter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'n> Debug for Finder<'n>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FinderBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'n> Debug for FinderRev<'n>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S, A> Debug for Matcher<'a, S, A> where
    A: Debug + DFA<ID = S>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, A> Debug for Pattern<S, A> where
    A: Debug + DFA<ID = S>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Regex<D> where
    D: Debug + DFA, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for SparseDFA<T, S> where
    T: Debug + AsRef<[u8]>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for Standard<T, S> where
    T: Debug + AsRef<[S]>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for DenseDFA<T, S> where
    T: Debug + AsRef<[S]>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RegexBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for Premultiplied<T, S> where
    T: Debug + AsRef<[S]>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for ByteClass<T, S> where
    T: Debug + AsRef<[S]>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for PremultipliedByteClass<T, S> where
    T: Debug + AsRef<[S]>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for Standard<T, S> where
    T: Debug + AsRef<[u8]>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for ByteClass<T, S> where
    T: Debug + AsRef<[u8]>,
    S: Debug + StateID, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LittleEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Suffix

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Colour

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Prefix

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Style

Styles have a special Debug implementation that only shows the fields that are set. Fields that haven’t been touched aren’t included in the output.

This behaviour gets bypassed when using the alternate formatting mode format!("{:#?}").

use ansi_term::Colour::{Red, Blue};
assert_eq!("Style { fg(Red), on(Blue), bold, italic }",
           format!("{:?}", Red.on(Blue).bold().italic()));

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for ANSIGenericStrings<'a, S> where
    S: 'a + Debug + ToOwned + PartialEq<S> + ?Sized,
    <S as ToOwned>::Owned: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Infix

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for ANSIGenericString<'a, S> where
    S: 'a + Debug + ToOwned + ?Sized,
    <S as ToOwned>::Owned: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LogTracer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Builder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for MetadataBuilder<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Record<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseLevelError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for RecordBuilder<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Level

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SetLoggerError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LevelFilter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Category

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Number

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Map<String, Value>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompactFormatter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SerializeId<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SerializeLevel<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for SerializeFieldMap<'a, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SerializeField

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SerializeEvent<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SerializeRecord<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SerializeAttributes<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SerializeFieldSet<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for SerdeMapVisitor<S> where
    S: Debug + SerializeMap,
    <S as SerializeMap>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SerializeMetadata<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for SerdeStructVisitor<S> where
    S: Debug + SerializeStruct,
    <S as SerializeStruct>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, C> Debug for OwnedEntry<T, C> where
    C: Config,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, C> Debug for OwnedRef<T, C> where
    C: Config,
    T: Debug + Clear + Default, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, C> Debug for Slab<T, C> where
    C: Config,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, C> Debug for VacantEntry<'a, T, C> where
    C: Debug + Config,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, C> Debug for RefMut<'a, T, C> where
    C: Config,
    T: Debug + Clear + Default, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, C> Debug for Entry<'a, T, C> where
    C: Config,
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DefaultConfig

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, C> Debug for OwnedRefMut<T, C> where
    C: Config,
    T: Debug + Clear + Default, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, C> Debug for Ref<'a, T, C> where
    C: Config,
    T: Debug + Clear + Default, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, C> Debug for Pool<T, C> where
    C: Config,
    T: Debug + Clear + Default, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ThreadLocal<T> where
    T: Send + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: Debug + Send + Sync, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: Send + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CachedThreadLocal<T> where
    T: Send + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug + Send, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F> Debug for Lazy<T, F> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OnceCell<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnceNonZeroUsize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F> Debug for Lazy<T, F> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OnceCell<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OnceBox<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnceBool

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WaitTimeoutResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OnceState

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Condvar

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Once

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockWriteGuard<'a, R, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawRwLock, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockReadGuard<'a, R, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawRwLock, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockReadGuard<'a, R, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawRwLock, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, T> Debug for Mutex<R, T> where
    T: Debug + ?Sized,
    R: RawMutex, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockWriteGuard<'a, R, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawRwLock, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, G, T> Debug for ReentrantMutexGuard<'a, R, G, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawMutex,
    G: 'a + GetThreadId, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for MutexGuard<'a, R, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawMutex, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockUpgradableReadGuard<'a, R, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawRwLockUpgrade, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, T> Debug for MappedMutexGuard<'a, R, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawMutex, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, G, T> Debug for ReentrantMutex<R, G, T> where
    T: Debug + ?Sized,
    R: RawMutex,
    G: GetThreadId, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, G, T> Debug for MappedReentrantMutexGuard<'a, R, G, T> where
    T: 'a + Debug + ?Sized,
    R: 'a + RawMutex,
    G: 'a + GetThreadId, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, T> Debug for RwLock<R, T> where
    T: Debug + ?Sized,
    R: RawRwLock, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, S> Debug for ScopeGuard<T, F, S> where
    T: Debug,
    F: FnOnce(T),
    S: Strategy, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Always

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnparkResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParkResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnparkToken

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParkToken

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RequeueOp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FilterOp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Array,
    <T as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CollectionAllocErr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Weekday

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Item<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Tz> Debug for DateTime<Tz> where
    Tz: TimeZone, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InternalFixed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NaiveTime

The Debug output of the naive time t is the same as t.format("%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn’t matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveTime;

assert_eq!(format!("{:?}", NaiveTime::from_hms(23, 56, 4)),              "23:56:04");
assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(23, 56, 4, 12)),    "23:56:04.012");
assert_eq!(format!("{:?}", NaiveTime::from_hms_micro(23, 56, 4, 1234)),  "23:56:04.001234");
assert_eq!(format!("{:?}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");

Leap seconds may also be used.

assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Parsed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for StrftimeItems<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pad

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InternalNumeric

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LocalResult<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Tz> Debug for Date<Tz> where
    Tz: TimeZone, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Numeric

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Fixed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RoundingError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NaiveDateTime

The Debug output of the naive date and time dt is the same as dt.format("%Y-%m-%dT%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn’t matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveDate;

let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");

Leap seconds may also be used.

let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Month

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for DelayedFormat<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SecondsFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseWeekdayError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Local

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FixedOffset

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Utc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseMonthError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NaiveDate

The Debug output of the naive date d is the same as d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

Example

use chrono::NaiveDate;

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IsoWeek

The Debug output of the ISO week w is the same as d.format("%G-W%V") where d is any NaiveDate value in that week.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5).iso_week()), "2015-W36");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  3).iso_week()), "0000-W01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31).iso_week()), "9999-W52");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(    0,  1,  2).iso_week()),  "-0001-W52");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31).iso_week()), "+10000-W52");

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Duration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ExtendedGcd<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FloatErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseFloatError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageKind

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CryptoTypeId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Timestamp

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for NativeOrEncoded<R> where
    R: Encode, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExternEntity

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PendingRequest

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Number, Hash> Debug for ChangesTrieConfigurationRange<Number, Hash> where
    Hash: Debug,
    Number: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TestPersistentOffchainDB

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CryptoTypePublicPair

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InMemOffchainStorage

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Capability

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AccountId32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for HexDisplay<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Capabilities

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Public

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpaqueNetworkState

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Public

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LocalizedSignature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LocalizedSignature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PublicError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SecretStringError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpaquePeerId

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for KeccakHasher

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EnvironmentDefinition

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PublicError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Entry

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpRequestStatus

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Public

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ss58AddressFormat

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OffchainState

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TestOffchainExt

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HostError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpaqueMultiaddr

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Blake2Hasher

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PublicError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OffchainOverlayedChange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Bytes

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChangesTrieConfiguration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for KeyTypeId

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DeriveJunction

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MissingHostFunctions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Duration

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for HttpRequestId

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CodeNotFound

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Infallible

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Pointer<T> where
    T: Debug + PointerType, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReturnValue

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValueType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExternVal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ResumableError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RuntimeValue

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TableInstance

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FuncRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValueType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TableRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MemoryRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for F64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FuncInstance

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GlobalRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GlobalInstance

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ModuleRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for F32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Trap

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MemoryInstance

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TrapKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for RuntimeArgs<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ModuleInstance

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pages

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pages

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Words

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Bytes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Words

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ModuleNameSubsection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BlockType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for External

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MemorySection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Func

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NameSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Type

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImportSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VarUint64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FunctionSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FuncBody

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for CountedWriter<'a, W> where
    W: 'a + Debug + Write, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FunctionType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IndexMap<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Local

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LocalNameSubsection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Uint64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Module

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GlobalType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VarUint1

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImportCountType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ElementSegment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Uint32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DataSegment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CountedList<T> where
    T: Debug + Deserialize, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Instruction

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TableSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VarUint7

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExportSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Section

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GlobalSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DataSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Internal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InitExpr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValueType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MemoryType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VarInt32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExportEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Instructions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Uint8

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImportEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CustomSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TableEntryDefinition

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TypeSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ResizableLimits

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TableType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FunctionNameSubsection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VarUint32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TableDefinition

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VarInt7

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CodeSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ElementSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TableElementType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, T> Debug for CountedListWriter<I, T> where
    I: Serialize<Error = Error> + Debug,
    T: Debug + IntoIterator<Item = I>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BrTableData

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VarInt64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for GlobalEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StartedWith

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StackValueType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BlockFrame

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ModuleContext

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for StackWithLimit<T> where
    T: Debug + Clone, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Locals<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Ratio<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseRatioError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sign

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigUint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigInt

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ParseBigIntError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Extensions

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TrackedStorageKey

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Hash> Debug for StorageChangeSet<Hash> where
    Hash: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChildTrieParentKeyId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PrefixedStorageKey

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageData

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageChild

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Storage

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageKey

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for H128

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U512

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U128

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for H512

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for H256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for H160

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for U256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromHexError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpenClosed01

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Standard

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for Uniform<X> where
    X: Debug + SampleUniform,
    <X as SampleUniform>::Sampler: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Bernoulli

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StepRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Open01

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D, R, T> Debug for DistIter<D, R, T> where
    T: Debug,
    R: Debug,
    D: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BernoulliError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UniformChar

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for UniformInt<X> where
    X: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S, T> Debug for SliceChooseIter<'a, S, T> where
    T: 'a + Debug,
    S: 'a + Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReadError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UniformDuration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for WeightedIndex<W> where
    W: Debug + Weight, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for UniformFloat<X> where
    X: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WeightedError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ReadRng<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexVec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Alphanumeric

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for WeightedIndex<X> where
    X: Debug + SampleUniform + PartialOrd<X>,
    <X as SampleUniform>::Sampler: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexVecIntoIter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for IndexVecIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BlockRng64<R> where
    R: BlockRngCore + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OsRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BlockRng<R> where
    R: BlockRngCore + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromStrRadixErr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromDecStrErr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromStrRadixErrKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromHexError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromHexError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Blake2bResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Blake2sResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Blake2b

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Blake2s

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayString<A> where
    A: Array<Item = u8>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CapacityError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha384

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512Trunc224

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512Trunc256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha224

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, N> Debug for GenericArray<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T, N> Debug for GenericArrayIter<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Equal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for B0

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for B1

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ATerm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U> Debug for PInt<U> where
    U: Debug + Unsigned + NonZero, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Less

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<V, A> Debug for TArr<V, A> where
    A: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U, B> Debug for UInt<U, B> where
    B: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UTerm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Greater

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<U> Debug for NInt<U> where
    U: Debug + Unsigned + NonZero, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Z0

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidOutputSize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for XxHash64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for XxHash32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for WeightedIndex<W> where
    W: Weight + Debug,
    Uniform<W>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UniformDuration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D, R, T> Debug for DistIter<D, R, T> where
    T: Debug,
    R: Debug,
    D: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ReadRng<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Beta

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for WeightedError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StudentT

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BernoulliError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Normal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexVecIntoIter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReadError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnitSphereSurface

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnitCircle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Standard

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Weibull

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Exp1

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Open01

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LogNormal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Alphanumeric

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StandardNormal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Triangular

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EntropyRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for UniformFloat<X> where
    X: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for UniformInt<X> where
    X: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SmallRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StdRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ThreadRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IndexVec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Binomial

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Exp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for IndexVecIter<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for Uniform<X> where
    X: Debug + SampleUniform,
    <X as SampleUniform>::Sampler: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChiSquared

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<X> Debug for WeightedIndex<X> where
    X: Debug + SampleUniform + PartialOrd<X>,
    <X as SampleUniform>::Sampler: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpenClosed01

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Poisson

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pareto

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Cauchy

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Gamma

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Bernoulli

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StepRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S, T> Debug for SliceChooseIter<'a, S, T> where
    T: 'a + Debug,
    S: 'a + Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FisherF

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Dirichlet

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OsRng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BlockRng64<R> where
    R: BlockRngCore + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BlockRng<R> where
    R: BlockRngCore + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha20Rng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha20Core

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha8Rng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha12Core

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha12Rng

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChaCha8Core

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Mcg128Xsl64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Lcg128Xsl64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Lcg64Xsh32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FromBase58Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Z> Debug for Zeroizing<Z> where
    Z: Debug + Zeroize, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for Secret<S> where
    S: Zeroize + DebugSecret, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PublicKey

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Keypair

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SecretKey

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MontgomeryPoint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EdwardsPoint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EdwardsBasepointTableRadix16

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressedRistretto

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RistrettoPoint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EdwardsBasepointTableRadix128

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressedEdwardsY

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EdwardsBasepointTableRadix32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Scalar

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EdwardsBasepointTableRadix256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EdwardsBasepointTableRadix64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CtOption<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Choice

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512Trunc224

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512Trunc256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha224

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha256

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha512

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sha384

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnpadError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PadError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, N> Debug for GenericArrayIter<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, N> Debug for GenericArray<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidOutputSize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Hmac<D> where
    D: Input + BlockInput + FixedOutput + Reset + Default + Clone + Debug,
    <D as BlockInput>::BlockSize: ArrayLength<u8>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MacError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidKeyLength

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Choice

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PublicKey

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MultiSignatureStage

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Keypair

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RistrettoBoth

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SignatureError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ECQVCertPublic

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Cosignature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K> Debug for ExtendedKey<K> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VRFProof

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VRFInOut

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SecretKey

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChainCode

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VRFProofBatchable

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Commitment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MiniSecretKey

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for VRFOutput

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressedRistretto

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Scalar

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EdwardsPoint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MontgomeryPoint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RistrettoPoint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressedEdwardsY

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EdwardsBasepointTable

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for CapacityError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Language

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Seed

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Mnemonic

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MnemonicType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for IsNormalized

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryFromSliceError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for ArrayVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for TinyVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for TinyVecIterator<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s, T> Debug for SliceVec<'s, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Hmac<D> where
    D: Update + BlockInput + FixedOutput + Reset + Default + Clone + Debug,
    <D as BlockInput>::BlockSize: ArrayLength<u8>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MacError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidKeyLength

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for SharedSecret<D> where
    D: Debug + Digest,
    <D as Digest>::OutputSize: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RecoveryId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AffineStorage

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PublicKey

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SecretKey

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Jacobian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Scalar

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Field

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Affine

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Message

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    T: Debug + Eq + Hash,
    S: BuildHasher, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for Entry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawOccupiedEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryReserveError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K> Debug for IntoIter<K> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilder<'_, K, V, S>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for OccupiedEntry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for SymmetricDifference<'_, T, S> where
    T: Debug + Eq + Hash,
    S: BuildHasher, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Union<'_, T, S> where
    T: Debug + Eq + Hash,
    S: BuildHasher, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for VacantEntry<'_, K, V, S> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, S> Debug for Difference<'_, T, S> where
    T: Debug + Eq + Hash,
    S: BuildHasher, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawVacantEntryMut<'_, K, V, S>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, K> Debug for Drain<'_, K> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for HashSet<T, S> where
    T: Eq + Hash + Debug,
    S: BuildHasher, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RandomState

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AHasher

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AtomicWaker

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Fuse<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for Read<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Shared<Fut> where
    Fut: Future, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for TryJoin5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    Fut5: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug,
    <Fut5 as TryFuture>::Ok: Debug,
    <Fut5 as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryBufferUnordered<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Enumerate<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for MapOk<Fut, F> where
    Map<IntoFuture<Fut>, MapOkFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for UnitError<Fut> where
    Map<Fut, OkFn<()>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for MutexLockFuture<'_, T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, Item> Debug for ReuniteError<T, Item>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, Item, E> Debug for SinkErrInto<Si, Item, E> where
    E: Debug,
    Item: Debug,
    Si: Debug + Sink<Item>,
    <Si as Sink<Item>>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Empty<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilter<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Cursor<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadToString<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryTakeWhile<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for FillBuf<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2> Debug for TryJoin<Fut1, Fut2> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadUntil<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for FlattenStream<F> where
    F: Future,
    Flatten<F, <F as Future>::Output>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for PollFn<F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for AndThen<Fut1, Fut2, F> where
    TryFlatten<MapOk<Fut1, F>, Fut2>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for BufferUnordered<St> where
    St: Stream + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for SelectNextSome<'a, St> where
    St: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, U, F> Debug for FlatMap<St, U, F> where
    Flatten<Map<St, F>, U>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Chunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for SkipWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for Next<'a, St> where
    St: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Map<St, F> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for IntoStream<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for OrElse<Fut1, Fut2, F> where
    TryFlattenErr<MapErr<Fut1, F>, Fut2>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Concat<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2> Debug for Chain<St1, St2> where
    St1: Debug,
    St2: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for FuturesOrdered<Fut> where
    Fut: Future, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for Join5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    Fut5: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug,
    <Fut5 as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Cycle<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, T> Debug for MapInto<Fut, T> where
    Map<Fut, IntoFn<T>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, E> Debug for OkInto<Fut, E> where
    MapOk<Fut, IntoFn<E>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for MaybeDone<Fut> where
    Fut: Debug + Future,
    <Fut as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, S, Fut, F> Debug for Scan<St, S, Fut, F> where
    S: Debug,
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Empty

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    T: Debug,
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Aborted

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for IntoIter<St> where
    St: Debug + Unpin, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, Si, St> Debug for SendAll<'_, Si, St> where
    Si: Debug + ?Sized,
    St: Debug + TryStream + ?Sized,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TakeWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for InspectOk<St, F> where
    Inspect<IntoStream<St>, InspectOkFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for Inspect<St, F> where
    Map<St, InspectFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Si, Item> Debug for Close<'a, Si, Item> where
    Item: Debug,
    Si: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, Item, U, Fut, F> Debug for With<Si, Item, U, Fut, F> where
    Fut: Debug,
    Si: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for IntoIter<Fut> where
    Fut: Debug + Unpin, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for TryJoin3<Fut1, Fut2, Fut3> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for Iter<'a, Fut> where
    Fut: Debug + Unpin, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Window<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for AndThen<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for TryJoinAll<F> where
    F: TryFuture + Debug,
    <F as TryFuture>::Ok: Debug,
    <F as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for TryNext<'a, St> where
    St: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for Iter<'a, St> where
    St: Debug + Unpin, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T, U> Debug for MappedMutexGuard<'_, T, U> where
    T: ?Sized,
    U: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for Map<Fut, F> where
    Map<Fut, F>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Remote<Fut> where
    Fut: Future + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, C> Debug for TryCollect<St, C> where
    C: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Sink

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, St> Debug for IterMut<'a, St> where
    St: Debug + Unpin, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for CatchUnwind<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for RepeatWith<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for Join3<Fut1, Fut2, Fut3> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si1, Si2> Debug for Fanout<Si1, Si2> where
    Si1: Debug,
    Si2: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for SelectAll<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Repeat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Abortable<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinRef<'a, Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, Item, U, St, F> Debug for WithFlatMap<Si, Item, U, St, F> where
    Item: Debug,
    Si: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for InspectErr<Fut, F> where
    Inspect<IntoFuture<Fut>, InspectErrFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Skip<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for Select<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for Join4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for StreamFuture<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for CatchUnwind<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W, Item> Debug for IntoSink<W, Item> where
    Item: Debug,
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryConcat<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, Item> Debug for Buffer<Si, Item> where
    Item: Debug,
    Si: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, St, T> Debug for NextIfEq<'_, St, T> where
    T: ?Sized,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for OptionFuture<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Iter<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, W> Debug for CopyBuf<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Si, F> Debug for SinkMapErr<Si, F> where
    F: Debug,
    Si: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Si, Item> Debug for Feed<'a, Si, Item> where
    Item: Debug,
    Si: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Drain<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Ready<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinMut<'a, Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for NeverError<Fut> where
    Map<Fut, OkFn<Infallible>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ReuniteError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, FromA, FromB> Debug for Unzip<St, FromA, FromB> where
    St: Debug,
    FromA: Debug,
    FromB: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for SelectOk<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2> Debug for Join<Fut1, Fut2> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for InspectErr<St, F> where
    Inspect<IntoStream<St>, InspectErrFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for TrySkipWhile<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Lines<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for Once<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Write<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, Item> Debug for SplitSink<S, Item> where
    Item: Debug,
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F, G> Debug for MapOkOrElse<Fut, F, G> where
    Map<IntoFuture<Fut>, ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, R> Debug for Unfold<T, F, R> where
    T: Debug,
    R: Debug,
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for JoinAll<F> where
    F: Future + Debug,
    <F as Future>::Output: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for Inspect<Fut, F> where
    Map<Fut, InspectFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for IntoFuture<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for UnwrapOrElse<Fut, F> where
    Map<IntoFuture<Fut>, UnwrapOrElseFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, C> Debug for Collect<St, C> where
    C: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Take<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Flatten<St> where
    St: Stream,
    Flatten<St, <St as Stream>::Item>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for MutexGuard<'_, T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F, Fut> Debug for TryUnfold<T, F, Fut> where
    T: Debug,
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Si, Item> Debug for Send<'a, Si, Item> where
    Item: Debug,
    Si: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AbortRegistration

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for MapErr<Fut, F> where
    Map<IntoFuture<Fut>, MapErrFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for PollFn<F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadToEnd<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AbortHandle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Flush<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Fuse<St> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for IntoAsyncRead<St> where
    St: Debug + TryStream<Error = Error> + Unpin,
    <St as TryStream>::Ok: AsRef<[u8]>,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, E> Debug for ErrInto<Fut, E> where
    MapErr<Fut, IntoFn<E>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Repeat<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for Close<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for TrySelect<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2> Debug for Select<St1, St2> where
    St1: Debug,
    St2: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, E> Debug for ErrInto<St, E> where
    MapErr<St, IntoFn<E>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for MapErr<St, F> where
    Map<IntoStream<St>, MapErrFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Take<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, T, F> Debug for TryFold<St, Fut, T, F> where
    T: Debug,
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for SplitStream<S> where
    S: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for IntoStream<F> where
    Once<F>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for Then<Fut1, Fut2, F> where
    Flatten<Map<Fut1, F>, Fut2>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S> Debug for Seek<'a, S> where
    S: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for Flatten<F> where
    F: Future,
    Flatten<F, <F as Future>::Output>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadExact<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Peekable<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, T, F> Debug for Fold<St, Fut, T, F> where
    T: Debug,
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryBuffered<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: TryFuture,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for SelectAll<Fut> where
    Fut: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadLine<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for WeakShared<Fut> where
    Fut: Future, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Si, Item> Debug for Flush<'a, Si, Item> where
    Item: Debug,
    Si: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2> Debug for TryFlatten<Fut1, Fut2> where
    TryFlatten<Fut1, Fut2>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for Either<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R, W> Debug for Copy<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for Buffered<St> where
    St: Stream + Debug,
    <St as Stream>::Item: Future, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, St, F> Debug for NextIf<'_, St, F> where
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, St> Debug for Peek<'_, St> where
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for TryFlatten<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for MapOk<St, F> where
    Map<IntoStream<St>, MapOkFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for WriteAll<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for FuturesUnordered<Fut>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, Si> Debug for FlattenSink<Fut, Si> where
    TryFlatten<Fut, Si>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut, F> Debug for InspectOk<Fut, F> where
    Inspect<IntoFuture<Fut>, InspectOkFn<F>>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Fut> Debug for IterMut<'a, Fut> where
    Fut: Debug + Unpin, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, W> Debug for WriteVectored<'a, W> where
    W: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for Filter<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for Then<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Si> Debug for Forward<St, Si> where
    St: TryStream,
    Forward<St, Si, <St as TryStream>::Ok>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for FilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for Lazy<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RemoteHandle<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for ReadVectored<'a, R> where
    R: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for AllowStdIo<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St1, St2> Debug for Zip<St1, St2> where
    St1: Debug + Stream,
    St2: Debug + Stream,
    <St1 as Stream>::Item: Debug,
    <St2 as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St> Debug for ReadyChunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut> Debug for TakeUntil<St, Fut> where
    Fut: Future + Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for TryJoin4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for TryFlattenStream<Fut> where
    Fut: TryFuture,
    TryFlatten<Fut, <Fut as TryFuture>::Ok>: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Fut> Debug for TryMaybeDone<Fut> where
    Fut: Debug + TryFuture,
    <Fut as TryFuture>::Ok: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, Fut, F> Debug for OrElse<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for LocalFutureObj<'_, T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SpawnError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'_, T> Debug for FutureObj<'_, T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for WakerRef<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Cancellation<'a, T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SendError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Canceled

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryRecvError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Enter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ThreadPoolBuilder

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EnterError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LocalPool

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LocalSpawner

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ThreadPool

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S> Debug for BlockingStream<S> where
    S: Debug + Stream + Unpin, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<H, N> Debug for CacheAction<H, N> where
    H: Debug,
    N: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UsageInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BackendTrustLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, S, H> Debug for ProvingBackend<'a, S, H> where
    H: 'a + Hasher,
    S: 'a + TrieBackendStorage<H>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExecutionError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<S, H> Debug for TrieBackend<S, H> where
    H: Hasher,
    S: TrieBackendStorage<H>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UsageUnit

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExecutionStrategy

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OverlayedChanges

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, H, B> Debug for ReadOnlyExternalities<'a, H, B> where
    H: Debug + Hasher,
    B: 'a + Debug + Backend<H>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<H, N> Debug for TestExternalities<H, N> where
    H: Hasher,
    N: BlockNumber,
    <H as Hasher>::Out: Ord,
    <H as Hasher>::Out: Codec, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OffchainOverlayedChanges

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StateMachineStats

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BasicExternalities

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Hash, Number> Debug for AnchorBlockId<Hash, Number> where
    Hash: Debug,
    Number: Debug + BlockNumber, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageProof

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NibbleVec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<HO, CE> Debug for Error<HO, CE> where
    HO: Debug,
    CE: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<HO> Debug for Recorder<HO> where
    HO: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'db, L> Debug for TrieDB<'db, L> where
    L: TrieLayout, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<HO> Debug for Record<HO> where
    HO: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<HO> Debug for ChildReference<HO> where
    HO: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NibbleSlicePlan

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodePlan

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NodeHandlePlan

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Node<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for OwnedNode<D> where
    D: Debug + Borrow<[u8]>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for NodeHandle<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for NibbleSlice<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TrieSpec

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, E> Debug for TrieError<T, E> where
    T: Debug,
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<H> Debug for HashKey<H>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<H> Debug for PrefixedKey<H>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<H> Debug for LegacyPrefixedKey<H> where
    H: Debug + Hasher, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BacktraceSymbol

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Frame

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Symbol

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for SymbolName<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BacktraceFrame

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Backtrace

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for BytesOrWideString<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TryDemangleError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for Demangle<'a>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'entry, 'unit, R> Debug for AttrsIter<'abbrev, 'entry, 'unit, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugRanges<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugLine<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AttributeSpecification

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwTag

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugStrOffsetsIndex<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ArangeEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Evaluation<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwEnd

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LineRow

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileEntryFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugLoc<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugArangesOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugInfo<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwIdx

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwDsc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Value

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for EhFrame<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugTypes<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugAddrIndex<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for FileEntry<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwarfFileType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RunTimeEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for CallFrameInstructionIter<'a, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RawRngListEntry<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugLineStr<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValueType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwDs

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwDefaulted

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwoId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugPubNames<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugFrameOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Abbreviations

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugStrOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ParsedEhFrameHdr<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugMacroOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'iter, R> Debug for RegisterRuleIter<'iter, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RawRngListIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, R> Debug for EntriesRaw<'abbrev, 'unit, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Offset> Debug for UnitType<Offset> where
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwVirtuality

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwCfa

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Format

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LocationListsOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugLineOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PubTypesEntry<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ArangeHeaderIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for X86

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for OperationIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RegisterRule<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Augmentation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugAranges<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LocationLists<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Register

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnitOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugMacinfoOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Pointer

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugInfoUnitHeadersIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for UninitializedUnwindContext<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ColumnType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DebugTypeSignature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for EhFrameHdr<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwEhPe

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for EhHdrTable<'a, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugRngLists<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwAddr

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwInl

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for CompleteLineProgram<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugTypesUnitHeadersIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugRngListsIndex<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, R> Debug for EntriesTree<'abbrev, 'unit, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PubNamesEntry<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LittleEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugRngListsBase<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugStrOffsetsBase<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnitSectionOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugLineStrOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Encoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LocationListEntry<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugTypesOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugAbbrevOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for IncompleteLineProgram<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwOrd

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for AttributeValue<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for UnitHeader<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugLocLists<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwAte

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for CfaRule<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LocListIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for EhFrameOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, R> Debug for UnwindTable<'a, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, R, Offset> Debug for DebuggingInformationEntry<'abbrev, 'unit, R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Expression<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for LineProgramHeader<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'input, Endian> Debug for EndianSlice<'input, Endian> where
    Endian: Debug + Endianity, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for UnwindContext<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for Piece<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwRle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Dwarf<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugLocListsBase<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwAccess

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for Unit<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, 'tree, R> Debug for EntriesTreeNode<'abbrev, 'unit, 'tree, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PubTypesEntryIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwAt

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LineSequence<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for Location<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugFrame<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Program, Offset> Debug for LineRows<R, Program, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset,
    Program: Debug + LineProgram<R, Offset>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for FrameDescriptionEntry<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RangeLists<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionBaseAddresses

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for LineInstructions<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwCc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLnct

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'bases, Section, R> Debug for CieOrFde<'bases, Section, R> where
    R: Debug + Reader,
    Section: Debug + UnwindSection<R>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugStr<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, R> Debug for EntriesCursor<'abbrev, 'unit, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DieReference<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugAbbrev<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugAddrBase<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ReaderOffsetId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RawLocListIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugPubTypes<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for X86_64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'bases, Section, R> Debug for CfiEntriesIter<'bases, Section, R> where
    R: Debug + Reader,
    Section: Debug + UnwindSection<R>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Range

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwMacro

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugAddr<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for PubNamesEntryIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for ArangeEntryIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BaseAddresses

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLang

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RangeListsOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwVis

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'bases, Section, R> Debug for PartialFrameDescriptionEntry<'bases, Section, R> where
    R: Debug + Reader,
    Section: Debug + UnwindSection<R>,
    <R as Reader>::Offset: Debug,
    <Section as UnwindSection<R>>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'abbrev, 'unit, 'tree, R> Debug for EntriesTreeIter<'abbrev, 'unit, 'tree, R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for EvaluationResult<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugLocListsIndex<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwForm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for CallFrameInstruction<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwUt

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for LineInstruction<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLne

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for DebugStrOffsets<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for Attribute<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwChildren

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLle

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RawLocListEntry<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Arm

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwLns

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for ArangeHeader<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for UnwindTableRow<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RngListIter<R> where
    R: Debug + Reader,
    <R as Reader>::Offset: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for Operation<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LineEncoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R, Offset> Debug for CommonInformationEntry<R, Offset> where
    R: Debug + Reader<Offset = Offset>,
    Offset: Debug + ReaderOffset, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for RangeIter<R> where
    R: Debug + Reader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DwOp

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Abbreviation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for DebugInfoOffset<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageLoadConfigCodeIntegrity

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for UuidCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOSectionIterator<'data, 'file, Mach, R> where
    R: ReadRef<'data>,
    Mach: MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressionFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FileHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, R> Debug for ArchiveMemberIterator<'data, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for ComdatSectionIterator<'data, 'file, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageFunctionEntry64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, R> Debug for ArchiveFile<'data, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SymbolScope

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageEnclaveConfig64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Relocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageCor20Header

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageRuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for EncryptionInfoCommand64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Section> Debug for SymbolFlags<Section> where
    Section: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for SymbolTable<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Endianness

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for CompressionHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, E> Debug for LoadCommandData<'data, E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageVxdHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe, R> Debug for PeSection<'data, 'file, Pe, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for SegmentIterator<'data, 'file, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachORelocationIterator<'data, 'file, Mach, R> where
    R: ReadRef<'data>,
    Mach: MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageTlsDirectory64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfSegmentIterator<'data, 'file, Elf, R> where
    R: Debug + ReadRef<'data>,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::ProgramHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibTableOfContents<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolCrc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FilesetEntryCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImportObjectHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for CoffSection<'data, 'file, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for SectionIterator<'data, 'file, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe, R> Debug for PeSegmentIterator<'data, 'file, Pe, R> where
    R: Debug + ReadRef<'data>,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for CoffComdat<'data, 'file, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Rel32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageRelocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for CompressionHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for ProgramHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionIndex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for LoadCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for CoffComdatIterator<'data, 'file, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SymbolSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FatArch32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for SymbolTable<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Sym: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnonObjectHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnonObjectHeaderV2

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe, R> Debug for PeComdatSectionIterator<'data, 'file, Pe, R> where
    R: Debug + ReadRef<'data>,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDirectoryEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FileHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for BuildVersionCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDirectory

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SymtabCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BinaryFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LittleEndian

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for Export<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDosHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FvmlibCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Sym32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for Bytes<'data>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, E> Debug for LoadCommandIterator<'data, E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for LcStr<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageLoadConfigDirectory64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolFunctionBeginEnd

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for CoffRelocationIterator<'data, 'file, R> where
    R: ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NoDynamicRelocationIterator

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDebugMisc

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DyldInfoCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibReference<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for EncryptionInfoCommand32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for RoutinesCommand32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SegmentCommand32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SymbolKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SubClientCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSymbolBytes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for RpathCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for LinkeditDataCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageHotPatchBase

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for CoffSegmentIterator<'data, 'file, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FatHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSymbolIterator<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for BuildToolVersion<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageRomOptionalHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibModule64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for TwolevelHint<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOComdatIterator<'data, 'file, Mach, R> where
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDataEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Sym64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylinkerCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I64Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ArchiveKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SourceVersionCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AddressSize

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfComdat<'data, 'file, Elf, R> where
    R: Debug + ReadRef<'data>,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug,
    <Elf as FileHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Dyn32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnonObjectHeaderBigobj

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressedFileRange

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I16Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfDynamicRelocationIterator<'data, 'file, Elf, R> where
    R: ReadRef<'data>,
    Elf: FileHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for EntryPointCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe, R> Debug for PeComdatIterator<'data, 'file, Pe, R> where
    R: Debug + ReadRef<'data>,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for SymbolMapName<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Nlist32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageBoundForwarderRef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for Import<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageImportByName

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for IdentCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for MachHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageArchiveMemberHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOSymbolTable<'data, 'file, Mach, R> where
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for ThreadCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSymbolEx

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOSymbol<'data, 'file, Mach, R> where
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Nlist: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfComdatIterator<'data, 'file, Elf, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, R> Debug for File<'data, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Dyn64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolFunction

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSymbolIterator<'data, 'file, Elf> where
    Elf: FileHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ComdatKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe, R> Debug for PeSegment<'data, 'file, Pe, R> where
    R: Debug + ReadRef<'data>,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for Segment<'data, 'file, R> where
    R: ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Syminfo64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for NonPagedDebugInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Header

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'table> Debug for SymbolIterator<'data, 'table>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for NoteHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageEnclaveConfig32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, E> Debug for LoadCommandVariant<'data, E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Dylib<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageNtHeaders32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Relocation<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageLinenumber

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSymbol<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for I32Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for CoffComdatSectionIterator<'data, 'file, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for CoffSegment<'data, 'file, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SectionHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SubFrameworkCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageArm64RuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSeparateDebugHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageArchitectureEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for VersionMinCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocation32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageTlsDirectory32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSymbol

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAlpha64RuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SegmentCommand64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe, R> Debug for PeComdat<'data, 'file, Pe, R> where
    R: Debug + ReadRef<'data>,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Rela64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for CompressedData<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageOs2Header

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DysymtabCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAlphaRuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for SymbolTable<'data, 'file, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SectionHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DylibModule32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for StringTable<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfSectionRelocationIterator<'data, 'file, Elf, R> where
    R: ReadRef<'data>,
    Elf: FileHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for PreboundDylibCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for NoteHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for NoteCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for TwolevelHintsCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Fvmlib<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Section64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for DataInCodeEntry<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Mach> Debug for SymbolTable<'data, Mach> where
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Nlist: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for Symbol<'data, 'file, R> where
    R: ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageArmRuntimeFunctionEntry

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageHotPatchInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SymbolIndex

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOComdat<'data, 'file, Mach, R> where
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageOptionalHeader32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, R> Debug for CoffFile<'data, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOSegment<'data, 'file, Mach, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Segment: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageCoffSymbolsHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ScatteredRelocationInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageLoadConfigDirectory32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageEnclaveImport

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for SymbolIterator<'data, 'file, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationEncoding

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfComdatSectionIterator<'data, 'file, Elf, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageEpilogueDynamicRelocationHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDirectoryString

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOSymbolIterator<'data, 'file, Mach, R> where
    R: ReadRef<'data>,
    Mach: MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for ArchiveMember<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Syminfo32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageFileHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Architecture

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocation64V2

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationTarget

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for MachHeader64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileFlags

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSectionHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for NoteIterator<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Mach, R> Debug for MachOFile<'data, Mach, R> where
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfSection<'data, 'file, Elf, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDebugDirectory

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageOptionalHeader64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Rel64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U64Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageBoundImportDescriptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for FvmfileCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for PeRelocationIterator<'data, 'file, R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolSection

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Nlist64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for SectionKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for Note<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::NoteHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocation32V2

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageRomHeaders

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOSegmentIterator<'data, 'file, Mach, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader,
    <Mach as MachHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for LinkerOptionCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfSectionIterator<'data, 'file, Elf, R> where
    R: Debug + ReadRef<'data>,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for ObjectMapEntry<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSymbolTable<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U32Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageHotPatchHashes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FatArch64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOComdatSectionIterator<'data, 'file, Mach, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageBaseRelocation

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for DynamicRelocationIterator<'data, 'file, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for ComdatIterator<'data, 'file, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageResourceDirStringU

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for PrebindCksumCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImagePrologueDynamicRelocationHeader

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for Section<'data, 'file, R> where
    R: ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SymsegCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for SectionTable<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for CoffSectionIterator<'data, 'file, R> where
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolWeak

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Ident

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RelocationSections

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDataDirectory

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageNtHeaders64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageImportDescriptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Mach, R> Debug for MachOSection<'data, 'file, Mach, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Mach: Debug + MachHeader, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf, R> Debug for ElfFile<'data, Elf, R> where
    R: Debug + ReadRef<'data>,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug,
    <Elf as FileHeader>::ProgramHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageSymbolExBytes

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for Comdat<'data, 'file, R> where
    R: ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Guid

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageExportDirectory

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Elf> Debug for SectionTable<'data, Elf> where
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::SectionHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf> Debug for ElfSymbol<'data, 'file, Elf> where
    'data: 'file,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::Endian: Debug,
    <Elf as FileHeader>::Sym: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Elf, R> Debug for ElfSegment<'data, 'file, Elf, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Elf: Debug + FileHeader,
    <Elf as FileHeader>::ProgramHeader: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocationTable

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDynamicRelocation64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SymbolMap<T> where
    T: Debug + SymbolMapEntry, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, Pe, R> Debug for PeSectionIterator<'data, 'file, Pe, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SubUmbrellaCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file, R> Debug for SectionRelocationIterator<'data, 'file, R> where
    'data: 'file,
    R: Debug + ReadRef<'data>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for SubLibraryCommand<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for ProgramHeader32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Section32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, Pe, R> Debug for PeFile<'data, Pe, R> where
    R: Debug + ReadRef<'data>,
    Pe: Debug + ImageNtHeaders, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for U16Bytes<E> where
    E: Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageAuxSymbolTokenDef

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for Rela32<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data, 'file> Debug for CoffSymbolTable<'data, 'file>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'data> Debug for ObjectMap<'data>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ImageDelayloadDescriptor

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FileKind

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<E> Debug for RoutinesCommand64<E> where
    E: Debug + Endian, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressionStrategy

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TDEFLStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CompressionLevel

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StreamResult

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DataFormat

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MZStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TINFLStatus

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MZFlush

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MZError

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TDEFLFlush

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Adler32

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RuntimeMetadataV12

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RuntimeMetadataDeprecated

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for HeadersIterator<'a>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TestSignature

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MultiSigner

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Response

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Method

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Xt> Debug for Block<Xt> where
    Xt: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PendingRequest

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BadOrigin

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StoredMapError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChangesTrieSignal

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BlakeTwo256

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, Hash> Debug for DigestItemRef<'a, Hash> where
    Hash: 'a + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UintAuthorityId

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RuntimeString

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Block> Debug for SignedBlock<Block> where
    Block: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for AnySignature

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ResponseBody

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Request<'a, T> where
    T: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OpaqueExtrinsic

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for MultiSignature

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Keccak256

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<AccountId, AccountIndex> Debug for MultiAddress<AccountId, AccountIndex> where
    AccountId: Debug,
    AccountIndex: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValidTransactionBuilder

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Address, Call, Signature, Extra> Debug for UncheckedExtrinsic<Address, Call, Signature, Extra> where
    Call: Debug,
    Address: Debug,
    Extra: SignedExtension, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Era

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Number, Hash> Debug for Header<Number, Hash> where
    Hash: Hash + Debug,
    Number: Copy + Into<U256> + TryFrom<U256> + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Call, Extra> Debug for TestXt<Call, Extra>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<AccountId, Call, Extra> Debug for CheckedExtrinsic<AccountId, Call, Extra> where
    Call: Debug,
    AccountId: Debug,
    Extra: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Headers

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Block> Debug for BlockId<Block> where
    Block: Block + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for LookupError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Hash> Debug for DigestItem<Hash> where
    Hash: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> Debug for PiecewiseLinear<'a>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Header, Extrinsic> Debug for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize + Debug,
    Header: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Xt> Debug for ExtrinsicWrapper<Xt> where
    Xt: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Hash> Debug for Digest<Hash> where
    Hash: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Info> Debug for DispatchErrorWithPostInfo<Info> where
    Info: Eq + PartialEq<Info> + Clone + Copy + Encode + Decode + Printable + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Public

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Public

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Signature

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Public

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Perbill

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FixedU128

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Rational128

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Percent

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FixedI128

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FixedI64

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Permill

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BigUint

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PerU16

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Perquintill

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<L, R> Debug for Either<L, R> where
    R: Debug,
    L: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OffenceError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Reporter, Offender> Debug for OffenceDetails<Reporter, Offender> where
    Reporter: Debug,
    Offender: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

Loading content...

Implementors

impl Debug for Alignment

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Never

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for Void

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RuntimeMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageEntryModifier

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageEntryType

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageHasher

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for DispatchError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for InvalidTransaction

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TransactionSource

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for TransactionValidityError

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for UnknownTransaction

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChildInfo

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ChildType

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for BalanceStatus

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for DispatchClass

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Pays

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for frame_support::dispatch::fmt::Error

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for PhantomPinned

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ErrorMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FunctionArgumentMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for FunctionMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ModuleConstantMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for EventMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for OuterEventMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for Instance0

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance1

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance2

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance3

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance4

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance5

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance6

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance7

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance8

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance9

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance10

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance11

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance12

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance13

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance14

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for Instance15

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for DefaultByteGetter

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ExtrinsicMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ModuleMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for RuntimeMetadataPrefixed

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageEntryMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for StorageMetadata

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for ValidTransaction

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl Debug for CallMetadata

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for PalletVersion

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for WithdrawReasons

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Debug for DispatchInfo

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for PostDispatchInfo

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl Debug for RuntimeDbWeight

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl<'_> Debug for Arguments<'_>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for frame_support::dispatch::result::Iter<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for frame_support::dispatch::result::IterMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B, O> Debug for DecodeDifferent<B, O> where
    O: Debug + Eq + 'static,
    B: Debug + Eq + 'static, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<BlockNumber> Debug for DispatchTime<BlockNumber> where
    BlockNumber: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl<E> Debug for FnEncode<E> where
    E: Encode + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for frame_support::dispatch::result::IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PhantomData<T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PerDispatchClass<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

impl<T, A> Debug for Vec<T, A> where
    T: Debug,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, E> Debug for Result<T, E> where
    T: Debug,
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Loading content...