Trait frame_support::dispatch::fmt::Debug

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

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Examples

Deriving an implementation:

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

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

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

Manually implementing:

use std::fmt;

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

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

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

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

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

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

Pretty-printing with #?:

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

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

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

Required methods

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

Formats the value using the given formatter.

Examples

use std::fmt;

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

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

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

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

Loading content...

Implementations on Foreign Types

impl Debug for SocketAddrV4

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

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

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

impl Debug for Thread

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

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

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

impl Debug for ThreadId

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

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

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

impl Debug for SocketAddr

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

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

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

impl Debug for OsString

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

impl Debug for DirEntry

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

impl Debug for Vars

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

impl Debug for ExitStatus

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

impl Debug for ChildStdin

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

impl Debug for Once

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

impl<T> Debug for TryLockError<T>

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

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

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

impl<T> Debug for PoisonError<T>

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

impl Debug for SocketAddr

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

impl Debug for BacktraceStatus

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

impl Debug for Empty

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

impl Debug for PathBuf

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

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

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

impl Debug for Command

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

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

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

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

impl<T> Debug for Sender<T>

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

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

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

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

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

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

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

impl Debug for SeekFrom

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

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

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

impl Debug for DirBuilder

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

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

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

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

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

impl Debug for Builder

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

impl<T> Debug for Key<T>

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

impl Debug for FromBytesWithNulError

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

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

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

impl Debug for UnixStream

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

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

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

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

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

impl Debug for Ipv6Addr

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

impl Debug for File

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

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

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

impl Debug for FileType

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

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

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

impl Debug for UdpSocket

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

impl Debug for Ipv6MulticastScope

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

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

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

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

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

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

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

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

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

impl Debug for Stderr

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

impl Debug for VarError

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

impl Debug for Output

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

impl Debug for Shutdown

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

impl Debug for Repeat

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

impl Debug for ErrorKind

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

impl Debug for Backtrace

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

impl Debug for AddrParseError

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

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

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

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

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

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

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

impl Debug for VarsOs

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

impl<T> Debug for SendError<T>

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

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

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

impl Debug for Stdout

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

impl Debug for IpAddr

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

impl<T> Debug for Receiver<T>

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

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

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

impl Debug for ExitCode

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

impl Debug for Error

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

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

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

impl Debug for RecvTimeoutError

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

impl Debug for UnixListener

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

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

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

impl Debug for NulError

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

impl Debug for RandomState

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

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

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

impl Debug for Barrier

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

impl Debug for ChildStderr

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

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

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

impl Debug for OpenOptions

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

impl Debug for Initializer

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

impl Debug for RecvError

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

impl<T> Debug for JoinHandle<T>

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

impl Debug for Stdio

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

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

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

impl Debug for Permissions

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

impl Debug for Path

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

impl Debug for TcpListener

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

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

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

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

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

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

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

impl Debug for TryRecvError

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

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

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

impl Debug for OsStr

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

impl Debug for OnceState

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

impl Debug for IntoStringError

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

impl Debug for System

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

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

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

impl Debug for AccessError

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

impl Debug for ReadDir

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

impl Debug for ArgsOs

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

impl Debug for Ipv4Addr

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

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

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

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

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

impl Debug for Args

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

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

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

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

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

impl Debug for ChildStdout

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

impl Debug for StripPrefixError

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

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

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

impl Debug for Instant

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

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

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

impl Debug for TcpStream

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

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

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

impl Debug for SystemTime

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Metadata

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

impl Debug for CStr

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

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

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

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

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

impl Debug for SocketAddrV6

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

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

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

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

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

impl Debug for UnixDatagram

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

impl Debug for Child

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

impl Debug for JoinPathsError

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

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

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

impl Debug for SystemTimeError

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

impl Debug for DefaultHasher

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

impl Debug for Condvar

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

impl Debug for CString

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

impl<T> Debug for SyncSender<T>

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

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

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

impl Debug for BarrierWaitResult

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

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

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

impl Debug for Sink

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

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

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

impl<T> Debug for TrySendError<T>

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

impl Debug for Stdin

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

impl<T> Debug for Key<T>

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

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

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

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

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

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

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

impl Debug for WaitTimeoutResult

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

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

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

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

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

impl<H> Debug for BuildHasherDefault<H>

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

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

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

impl Debug for __m256

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

impl Debug for ParseCharError

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

impl Debug for Layout

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

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

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

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

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

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

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

impl Debug for AtomicU8

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

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

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

impl Debug for __m512

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for i128

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

impl Debug for AtomicI8

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

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

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

impl Debug for Utf8Error

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

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

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

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

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

impl Debug for ToUppercase

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

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

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

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

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

impl Debug for NonZeroU64

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

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

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

impl Debug for ToLowercase

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

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

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

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

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

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

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

impl Debug for i16

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

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

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

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

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

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

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

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

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

impl Debug for isize

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

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

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

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

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

impl Debug for IntErrorKind

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

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

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

impl Debug for __m256i

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for char

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

impl Debug for i32

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

impl Debug for RawWaker

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

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

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

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

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

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

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

impl Debug for ParseFloatError

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

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

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

impl Debug for FpCategory

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

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

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

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

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

impl Debug for TryFromSliceError

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

impl Debug for AtomicBool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for u64

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

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

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

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

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

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

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

impl Debug for dyn Any + 'static

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TypeId

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

impl Debug for EscapeDebug

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

impl Debug for Utf8Lossy

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

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

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

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

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

impl Debug for BorrowError

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

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

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

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

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

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

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

impl Debug for f32

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

impl Debug for i8

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

impl Debug for NonZeroUsize

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

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

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

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

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

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

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

impl Debug for u128

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

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

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

impl Debug for AtomicI16

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

impl Debug for NonZeroI8

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

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

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

impl Debug for AtomicI32

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

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

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

impl Debug for Ordering

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

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

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

impl Debug for SearchStep

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

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

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

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

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

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

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

impl Debug for NonZeroI64

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

impl Debug for !

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

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

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

impl Debug for NonZeroU32

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

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

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

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

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

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

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

impl<T> Debug for Discriminant<T>

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

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

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

impl<T> Debug for AtomicPtr<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for f64

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

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

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

impl Debug for AtomicI64

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

impl Debug for __m128

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

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

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

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

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

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

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

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

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

impl Debug for __m512i

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

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

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

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

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

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

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

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

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

impl<T> Debug for MaybeUninit<T>

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

impl Debug for __m256d

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

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

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

impl Debug for AtomicIsize

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

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

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

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

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

impl Debug for AllocInit

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

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

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

impl Debug for AllocErr

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

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

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

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

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

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

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

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

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

impl Debug for Infallible

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

impl Debug for LayoutErr

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

impl Debug for usize

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

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

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

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

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

impl Debug for CharTryFromError

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

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

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

impl Debug for u32

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

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

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

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

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

impl Debug for ParseIntError

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

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

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

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

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

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

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

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

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

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

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

impl Debug for __m512d

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

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

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

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

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

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

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

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

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

impl Debug for ParseBoolError

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

impl Debug for AtomicU16

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

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

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

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

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

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

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

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

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

impl Debug for BorrowMutError

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

impl Debug for NonZeroU8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Duration

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

impl Debug for c_void

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

impl Debug for u16

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

impl Debug for AtomicU32

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

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

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

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

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

impl Debug for NonZeroIsize

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

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

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

impl Debug for NonZeroI128

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

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

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

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

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

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

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

impl Debug for NonZeroU16

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

impl Debug for ()

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

impl Debug for CpuidResult

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

impl Debug for SipHasher

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

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

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

impl Debug for EscapeDefault

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

impl Debug for AtomicUsize

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

impl Debug for TryFromIntError

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

impl<F> Debug for FromFn<F>

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

impl Debug for NonZeroI16

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

impl<T> Debug for Empty<T>

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

impl Debug for DecodeUtf16Error

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

impl Debug for NoneError

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

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

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

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

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

impl Debug for i64

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

impl Debug for __m128d

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

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

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

impl Debug for Waker

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for bool

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

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

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

impl Debug for str

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

impl Debug for __m64

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

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

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

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

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

impl Debug for MemoryBlock

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

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

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

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

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

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

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

impl Debug for Ordering

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

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

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

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

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

impl Debug for u8

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

impl Debug for RawWakerVTable

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for RangeFull

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

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

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

impl Debug for EscapeUnicode

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

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

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

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

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

impl Debug for dyn Any + 'static + Send

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

impl Debug for __m128i

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

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

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

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

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

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

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

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

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

impl Debug for NonZeroI32

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

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

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

impl Debug for AtomicU64

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

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

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

impl Debug for NonZeroU128

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

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

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

impl Debug for EscapeDefault

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for ReallocPlacement

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for FromUtf8Error

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

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

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

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

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

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

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

impl Debug for TryReserveError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for VacantEntry<'_, K, V> where
    K: Ord + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for Intersection<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for VecDeque<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIterSorted<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, F> Debug for DrainFilter<'_, T, F> where
    F: FnMut(&T) -> bool,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromUtf16Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Global

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BTreeSet<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rc<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LinkedList<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for String

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for Union<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RangeMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_> Debug for Drain<'_>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Entry<'_, K, V> where
    K: Ord + Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _Unwind_Reason_Code

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SymbolName<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Frame

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BytesOrWideString<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Symbol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Demangle<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryDemangleError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for VacantEntry<'_, K, V, S> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Debug,
    S: BuildHasher,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RawOccupiedEntryMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CollectionAllocErr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K> Debug for IntoIter<K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K> Debug for Drain<'_, K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RustcOccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RustcEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawVacantEntryMut<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for Entry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for OccupiedEntry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilder<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RustcVacantEntry<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LevelFilter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Span

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Entered<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dispatch

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Empty

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Identifier

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Field

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Record<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for DebugValue<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Interest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Id

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Event<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultGuard

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetGlobalDefaultError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Kind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ValueSet<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for DisplayValue<T> where
    T: Display, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Attributes<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseLevelError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Current

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Iter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FieldSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IgnoredAny

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I128Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U128Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OptionBool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Compact<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CapacityError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for OnceCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for OnceCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F> Debug for Lazy<T, F> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F> Debug for Lazy<T, F> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Condvar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Once

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitTimeoutResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OnceState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockWriteGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockReadGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, G, T> Debug for ReentrantMutex<R, G, T> where
    G: GetThreadId,
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MutexGuard<'a, R, T> where
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockReadGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for RwLockUpgradableReadGuard<'a, R, T> where
    R: 'a + RawRwLockUpgrade,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, G, T> Debug for ReentrantMutexGuard<'a, R, G, T> where
    G: 'a + GetThreadId,
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for RwLock<R, T> where
    R: RawRwLock,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedRwLockWriteGuard<'a, R, T> where
    R: 'a + RawRwLock,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for Mutex<R, T> where
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, G, T> Debug for MappedReentrantMutexGuard<'a, R, G, T> where
    G: 'a + GetThreadId,
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, T> Debug for MappedMutexGuard<'a, R, T> where
    R: 'a + RawMutex,
    T: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Always

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, S> Debug for ScopeGuard<T, F, S> where
    F: FnOnce(T),
    S: Strategy,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RequeueOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S, H> Debug for ProvingBackend<'a, S, H> where
    H: 'a + Hasher,
    S: 'a + TrieBackendStorage<H>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, H> Debug for TrieBackend<S, H> where
    H: Hasher,
    S: TrieBackendStorage<H>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BackendTrustLevel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UsageInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BasicExternalities

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StateMachineStats

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExecutionStrategy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<H, N> Debug for CacheAction<H, N> where
    H: Debug,
    N: Debug, 

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: Codec, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UsageUnit

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OverlayedChanges

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExecutionError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<H> Debug for InMemory<H> where
    H: Hasher, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Hash, Number> Debug for AnchorBlockId<Hash, Number> where
    Hash: Debug,
    Number: BlockNumber + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LevelFilter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Record<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for MetadataBuilder<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for RecordBuilder<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseLevelError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetLoggerError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bytes

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Capabilities

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Duration

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for AccountId32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublicError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Capability

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TestOffchainExt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DeriveJunction

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Blake2Hasher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublicError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timestamp

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Infallible

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ExternEntity

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for CryptoTypePublicPair

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Public

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HttpError

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for BareCryptoStoreError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SecretStringError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Public

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalizedSignature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OffchainState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Entry

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for KeyTypeId

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OpaquePeerId

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for EnvironmentDefinition

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for CodeNotFound

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HttpRequestStatus

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Protected<T> where
    T: Zeroize, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for HexDisplay<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalizedSignature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpaqueNetworkState

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<R> Debug for NativeOrEncoded<R> where
    R: Encode, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Public

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Number, Hash> Debug for ChangesTrieConfigurationRange<Number, Hash> where
    Hash: Debug,
    Number: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InMemOffchainStorage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublicError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CryptoTypeId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PendingRequest

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpaqueMultiaddr

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Executor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HttpRequestId

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StorageKind

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for HostError

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ChangesTrieConfiguration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Blake2sResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Blake2s

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Blake2bResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Blake2b

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayString<A> where
    A: Array<Item = u8>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CapacityError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha512Trunc256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha512Trunc224

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha224

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha384

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sha512

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LittleEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnpadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, N> Debug for GenericArray<T, N> where
    N: ArrayLength<T>,
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T, N> Debug for GenericArrayIter<T, N> where
    N: ArrayLength<T>,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UTerm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Greater

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<U> Debug for NInt<U> where
    U: NonZero + Unsigned + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<U, B> Debug for UInt<U, B> where
    B: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ATerm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for B0

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for B1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Equal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Z0

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Less

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<V, A> Debug for TArr<V, A> where
    A: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<U> Debug for PInt<U> where
    U: NonZero + Unsigned + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidOutputSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XxHash32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XxHash64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for UniformFloat<X> where
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bernoulli

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StandardNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnitSphereSurface

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S, T> Debug for SliceChooseIter<'a, S, T> where
    S: 'a + Debug + ?Sized,
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for UniformInt<X> where
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for WeightedIndex<W> where
    W: Weight + Debug,
    Uniform<W>: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Normal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenClosed01

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IndexVecIntoIter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for ReadRng<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Binomial

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StepRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StdRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StudentT

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pareto

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D, R, T> Debug for DistIter<D, R, T> where
    D: Debug,
    R: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EntropyRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Open01

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IndexVec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for WeightedIndex<X> where
    X: SampleUniform + PartialOrd<X> + Debug,
    <X as SampleUniform>::Sampler: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gamma

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReadError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Cauchy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Beta

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Weibull

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for Uniform<X> where
    X: SampleUniform + Debug,
    <X as SampleUniform>::Sampler: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Triangular

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UniformDuration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Alphanumeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dirichlet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WeightedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChiSquared

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Standard

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for IndexVecIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LogNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BernoulliError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnitCircle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FisherF

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Poisson

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OsRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BlockRng64<R> where
    R: BlockRngCore + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BlockRng<R> where
    R: BlockRngCore + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha20Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha20Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha8Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha8Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha12Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaCha12Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitTimeoutResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Once

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OnceState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Condvar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RequeueOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Array,
    <T as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RegexSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Regex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Shows the original regular expression.

impl Debug for CaptureLocations

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetMatches

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Regex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Shows the original regular expression.

impl Debug for CaptureLocations

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Match<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RegexSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetMatches

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Match<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindOverlappingIter<'a, 'b, S> where
    S: 'a + StateID + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, S> Debug for StreamFindIter<'a, R, S> where
    R: Debug,
    S: 'a + StateID + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, 'b, S> Debug for FindIter<'a, 'b, S> where
    S: 'a + StateID + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'s, 'h> Debug for FindIter<'s, 'h>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Searcher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for AhoCorasick<S> where
    S: StateID + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MatchKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Match

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MatchKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AhoCorasickBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassAscii

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Class

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpecialLiteralKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetBinaryOpKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Hir

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parser

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Alternation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnicodeWordError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParserBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Repetition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CaseFoldError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicodeKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parser

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParserBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Printer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Assertion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Concat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicodeOpKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicodeRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WordBoundary

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HexLiteralKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Span

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Flag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassBytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AssertionKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Utf8Sequence

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassBytesRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Repetition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassBracketed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassPerlKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Group

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetBinaryOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetRange

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Translator

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LiteralKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ClassBytesIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ast

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WithComments

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GroupKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Group

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Utf8Range

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HirKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RepetitionKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GroupKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TranslatorBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Literal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetUnion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlagsItem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Printer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FlagsItemKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Comment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Flags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Anchor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ClassUnicodeIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Class

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Literals

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassAsciiKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassPerl

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CaptureName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassUnicode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ClassSetItem

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ThreadLocal<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CachedThreadLocal<T> where
    T: Send + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromBase58Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Z> Debug for Zeroizing<Z> where
    Z: Zeroize + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReturnValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Pointer<T> where
    T: PointerType + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ValueType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlobalRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResumableError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for F32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlobalInstance

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleInstance

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TableRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for F64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemoryRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TableInstance

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemoryInstance

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RuntimeValue

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Trap

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FuncInstance

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for RuntimeArgs<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TrapKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FuncRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExternVal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ValueType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Words

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bytes

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pages

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pages

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Words

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FunctionNameSubsection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DataSegment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Uint32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ValueType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FunctionSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Uint64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IndexMap<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlobalEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImportCountType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for CountedWriter<'a, W> where
    W: 'a + Write + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Instructions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Instruction

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TableEntryDefinition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RelocationEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CountedList<T> where
    T: Deserialize + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CodeSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImportSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarUint64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DataSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TableType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalNameSubsection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemorySection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarUint7

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, T> Debug for CountedListWriter<I, T> where
    I: Debug + Serialize<Error = Error>,
    T: IntoIterator<Item = I> + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlobalSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GlobalType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InitExpr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MemoryType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ElementSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Func

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BlockType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarInt32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TableElementType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ImportEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarUint32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Module

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResizableLimits

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FunctionType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TypeSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Internal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Section

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TableSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TableDefinition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RelocSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExportSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarInt7

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExportEntry

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CustomSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarUint1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ElementSegment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for External

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BrTableData

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FuncBody

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Local

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VarInt64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Uint8

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleNameSubsection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NameSection

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BlockFrame

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StartedWith

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StackValueType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleContext

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for StackWithLimit<T> where
    T: Debug + Clone, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Locals<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseRatioError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Ratio<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigInt

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sign

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseBigIntError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigUint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ExtendedGcd<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FloatErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseFloatError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StorageData

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Hash> Debug for StorageChangeSet<Hash> where
    Hash: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OwnedChildTrie

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StorageChild

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StorageKey

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OwnedChildInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Storage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for U256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for U128

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for H512

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for H256

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for U512

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for H160

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromHexError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromDecStrErr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D> Debug for Hmac<D> where
    D: Input + BlockInput + FixedOutput + Reset + Default + Clone + Debug,
    <D as BlockInput>::BlockSize: ArrayLength<u8>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidKeyLength

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MacError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Choice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VRFOutput

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MiniSecretKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VRFInOut

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RistrettoBoth

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Keypair

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChainCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ECQVCertPublic

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K> Debug for ExtendedKey<K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignatureError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VRFProof

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SecretKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for VRFProofBatchable

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Cosignature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublicKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MultiSignatureStage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Commitment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EdwardsBasepointTable

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RistrettoPoint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressedEdwardsY

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MontgomeryPoint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EdwardsPoint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CompressedRistretto

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Scalar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CtOption<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Choice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mnemonic

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MnemonicType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Language

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Seed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Compat<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D> Debug for Context<D> where
    D: 'static + Send + Sync + Display, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SyncFailure<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Backtrace

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Frame

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Symbol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for BytesOrWideString<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BacktraceFrame

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SymbolName<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Backtrace

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for BacktraceSymbol

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for TryDemangleError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Demangle<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsNormalized

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Jacobian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Scalar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublicKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SecretKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Affine

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Message

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D> Debug for SharedSecret<D> where
    D: Debug + Digest,
    <D as Digest>::OutputSize: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecoveryId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Field

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AffineStorage

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AtomicWaker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for OptionFuture<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Iter<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2> Debug for TryJoin<Fut1, Fut2> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for OrElse<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for InspectOk<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for Map<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FlattenStream<Fut> where
    Fut: Future + Debug,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Cursor<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for WriteVectored<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for Select<St1, St2> where
    St1: Debug,
    St2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, E> Debug for ErrInto<Fut, E> where
    E: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Repeat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for MapErr<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for PollFn<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinMut<'a, Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, Item> Debug for SplitSink<S, Item> where
    Item: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, S, Fut, F> Debug for Scan<St, S, Fut, F> where
    Fut: Debug,
    S: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Window<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Aborted

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Ready<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Flatten<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Abortable<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for Zip<St1, St2> where
    St1: Debug + Stream,
    St2: Debug + Stream,
    <St1 as Stream>::Item: Debug,
    <St2 as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Empty<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for NeverError<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for AndThen<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for Read<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for UnwrapOrElse<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si, F> Debug for SinkMapErr<Si, F> where
    F: Debug,
    Si: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Repeat<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FuturesUnordered<Fut>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for IntoFuture<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Fuse<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Shared<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for Then<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for FilterMap<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, W> Debug for Copy<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for MapErr<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for SelectNextSome<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for AndThen<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for Next<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Remote<Fut> where
    Fut: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, T, F> Debug for Fold<St, Fut, T, F> where
    Fut: Debug,
    St: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for Iter<'a, Fut> where
    Fut: Unpin + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for Join5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    Fut5: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug,
    <Fut5 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    Fut: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, C> Debug for Collect<St, C> where
    C: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for MapOk<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for SelectAll<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for MapOk<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for Close<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for UnitError<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for WriteAll<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Either<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, U> Debug for MappedMutexGuard<'_, T, U> where
    T: ?Sized,
    U: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for Map<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for OrElse<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sink

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, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for Seek<'a, S> where
    S: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for BufferUnordered<St> where
    St: Stream + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadLine<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AbortHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryFilter<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadExact<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for IterPinRef<'a, Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St1, St2> Debug for Chain<St1, St2> where
    St1: Debug,
    St2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for IntoStream<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, Item> Debug for ReuniteError<T, Item>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for SelectOk<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for InspectErr<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Si, Item> Debug for Send<'a, Si, Item> where
    Item: Debug,
    Si: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for TrySelect<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Take<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryFlatten<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, F> Debug for Then<Fut1, Fut2, F> where
    F: Debug,
    Fut1: Debug,
    Fut2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for Lazy<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for JoinAll<F> where
    F: Future + Debug,
    <F as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AbortRegistration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Fut> Debug for IterMut<'a, Fut> where
    Fut: Unpin + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for SplitStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for MutexLockFuture<'_, T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2> Debug for Join<Fut1, Fut2> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W, Item> Debug for IntoSink<W, Item> where
    Item: Debug,
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for ForEach<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TryForEachConcurrent<St, Fut, F> where
    Fut: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, Si> Debug for FlattenSink<Fut, Si> where
    Fut: Debug + TryFuture<Ok = Si>,
    Si: Debug, 

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, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for MaybeDone<Fut> where
    Fut: Debug + Future,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Take<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si1, Si2> Debug for Fanout<Si1, Si2> where
    Si1: Debug,
    Si2: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for InspectErr<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for SelectAll<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, St> Debug for TryNext<'a, St> where
    St: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for TryJoinAll<F> where
    F: TryFuture + Debug,
    <F as TryFuture>::Ok: Debug,
    <F as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for SkipWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryConcat<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Lines<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for IntoStream<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for Join4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    Fut4: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug,
    <Fut4 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R, W> Debug for CopyBuf<'a, R, W> where
    R: Debug,
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Si, Item> Debug for Flush<'a, Si, Item> where
    Item: Debug,
    Si: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Debug for TryJoin5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    Fut5: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug,
    <Fut5 as TryFuture>::Ok: Debug,
    <Fut5 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, Si, St> Debug for SendAll<'_, Si, St> where
    Si: Debug + ?Sized,
    St: Debug + TryStream + ?Sized,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for StreamFuture<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for TryJoin3<Fut1, Fut2, Fut3> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for TryFlattenStream<Fut> where
    Fut: TryFuture + Debug,
    <Fut as TryFuture>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for Flush<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for TryBufferUnordered<St> where
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Select<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AllowStdIo<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Buffered<St> where
    St: Stream + Debug,
    <St as Stream>::Item: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, Si, Item> Debug for Close<'a, Si, Item> where
    Item: Debug,
    Si: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Pending<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Si, Item> Debug for Buffer<Si, Item> where
    Item: Debug,
    Si: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, E> Debug for ErrInto<St, E> where
    E: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Si> Debug for Forward<St, Si> where
    Si: Debug,
    St: Debug + TryStream,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for FuturesOrdered<Fut> where
    Fut: Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for PollFn<F>

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, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for Inspect<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Drain<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TakeWhile<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadToEnd<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadToString<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, St> Debug for Peek<'_, St> where
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadUntil<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Empty

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Flatten<Fut> where
    Fut: Future + Debug,
    <Fut as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for TrySkipWhile<St, Fut, F> where
    Fut: Debug,
    St: TryStream + Debug,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Concat<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for CatchUnwind<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, F> Debug for Filter<St, Fut, F> where
    Fut: Debug,
    St: Stream + Debug,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for Once<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for Write<'a, W> where
    W: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for IntoAsyncRead<St> where
    St: Debug + TryStream<Error = Error> + Unpin,
    <St as TryStream>::Ok: AsRef<[u8]>,
    <St as TryStream>::Ok: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, Fut, T, F> Debug for TryFold<St, Fut, T, F> where
    Fut: Debug,
    St: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3, Fut4> Debug for TryJoin4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: TryFuture + Debug,
    Fut2: TryFuture + Debug,
    Fut3: TryFuture + Debug,
    Fut4: TryFuture + Debug,
    <Fut1 as TryFuture>::Ok: Debug,
    <Fut1 as TryFuture>::Error: Debug,
    <Fut2 as TryFuture>::Ok: Debug,
    <Fut2 as TryFuture>::Error: Debug,
    <Fut3 as TryFuture>::Ok: Debug,
    <Fut3 as TryFuture>::Error: Debug,
    <Fut4 as TryFuture>::Ok: Debug,
    <Fut4 as TryFuture>::Error: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for Inspect<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Fuse<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut, F> Debug for InspectOk<Fut, F> where
    F: Debug,
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut> Debug for CatchUnwind<Fut> where
    Fut: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Skip<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Enumerate<St> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Chunks<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for RemoteHandle<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for ReadVectored<'a, R> where
    R: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, C> Debug for TryCollect<St, C> where
    C: Debug,
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, Fut> Debug for TryUnfold<T, F, Fut> where
    Fut: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Fut1, Fut2, Fut3> Debug for Join3<Fut1, Fut2, Fut3> where
    Fut1: Future + Debug,
    Fut2: Future + Debug,
    Fut3: Future + Debug,
    <Fut1 as Future>::Output: Debug,
    <Fut2 as Future>::Output: Debug,
    <Fut3 as Future>::Output: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St> Debug for Peekable<St> where
    St: Debug + Stream,
    <St as Stream>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for MutexGuard<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpawnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for WakerRef<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for FutureObj<'_, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for LocalFutureObj<'_, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Canceled

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SendError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Enter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for BlockingStream<S> where
    S: Unpin + Debug + Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EnterError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPoolBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalSpawner

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromHexError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PublicKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Keypair

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SignatureError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SecretKey

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for ClearOnDrop<P> where
    P: DerefMut + Debug,
    <P as Deref>::Target: Clear, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StorageProof

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NibbleVec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'db, L> Debug for TrieDB<'db, L> where
    L: TrieLayout, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NodeHandlePlan

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<HO> Debug for ChildReference<HO> where
    HO: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for NodeHandle<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NibbleSlicePlan

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for TrieError<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for NibbleSlice<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<HO> Debug for Recorder<HO> where
    HO: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<D> Debug for OwnedNode<D> where
    D: Borrow<[u8]> + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<HO> Debug for Record<HO> where
    HO: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Node<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TrieSpec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<HO, CE> Debug for Error<HO, CE> where
    CE: Debug,
    HO: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NodePlan

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for RawOccupiedEntryMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for ValuesMut<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Debug,
    S: BuildHasher,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K> Debug for Iter<'_, K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Keys<'_, K, V> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilder<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for VacantEntry<'_, K, V, S> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawVacantEntryMut<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CollectionAllocErr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K> Debug for Drain<'_, K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K> Debug for IntoIter<K> where
    K: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for OccupiedEntry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V> Debug for Values<'_, K, V> where
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, K, V, S> Debug for Entry<'_, K, V, S> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T, S> Debug for Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AHasher

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<H> Debug for PrefixedKey<H>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<H> Debug for LegacyPrefixedKey<H> where
    H: Debug + Hasher, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<H> Debug for HashKey<H>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RuntimeMetadataV11

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for RuntimeMetadataDeprecated

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Hash> Debug for DigestItem<Hash> where
    Hash: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Request<'a, T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Method

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, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Block> Debug for BlockId<Block> where
    Block: Block + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Headers

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for MultiSignature

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<AccountId, Call, Extra> Debug for CheckedExtrinsic<AccountId, Call, Extra> where
    AccountId: Debug,
    Call: Debug,
    Extra: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Xt> Debug for Block<Xt> where
    Xt: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnknownTransaction

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for PendingRequest

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Call, Extra> Debug for TestXt<Call, Extra>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for TransactionSource

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for TransactionValidityError

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ValidTransaction

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ValidTransactionBuilder

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Block> Debug for SignedBlock<Block> where
    Block: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ChangesTrieSignal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UintAuthorityId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpaqueExtrinsic

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for LookupError

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Address, Call, Signature, Extra> Debug for UncheckedExtrinsic<Address, Call, Signature, Extra> where
    Address: Debug,
    Call: Debug,
    Extra: SignedExtension, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Header

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RuntimeString

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for HeadersIterator<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseBody

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, Hash> Debug for DigestItemRef<'a, Hash> where
    Hash: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Response

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidTransaction

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PiecewiseLinear<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Era

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Number, Hash> Debug for Header<Number, Hash> where
    Hash: Hash + Debug,
    Number: Into<U256> + TryFrom<U256> + Copy + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Header, Extrinsic> Debug for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize + Debug,
    Header: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Xt> Debug for ExtrinsicWrapper<Xt> where
    Xt: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BlakeTwo256

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for AnySignature

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for MultiSigner

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<Hash> Debug for Digest<Hash> where
    Hash: Encode + Decode + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Public

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Signature

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Public

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Rational128

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Fixed128

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Perbill

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for BigUint

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PerU16

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Fixed64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Permill

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Perquintill

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Percent

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Loading content...

Implementors

impl Debug for DispatchError

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Alignment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Void

fn fmt(&self, fmt: &mut Formatter) -> Result

impl Debug for RuntimeMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StorageEntryModifier

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StorageEntryType

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StorageHasher

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for WithdrawReason

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for DispatchClass

fn fmt(&self, fmt: &mut Formatter) -> Result

impl Debug for frame_support::dispatch::fmt::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PhantomPinned

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for FunctionArgumentMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for FunctionMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleConstantMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for EventMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OuterEventMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultByteGetter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExtrinsicMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ModuleMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for RuntimeMetadataPrefixed

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StorageEntryMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StorageMetadata

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for CallMetadata

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 Arguments<'_>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for frame_support::dispatch::result::Iter<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for frame_support::dispatch::result::IterMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B, O> Debug for DecodeDifferent<B, O> where
    B: Debug + Eq + 'static,
    O: Debug + Eq + 'static, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for FnEncode<E> where
    E: Debug + Encode, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for PhantomData<T> where
    T: ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for frame_support::dispatch::result::IntoIter<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Vec<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Result<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Loading content...