1.0.0[][src]Trait frame_support::dispatch::fmt::Debug

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

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Stability

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

Examples

Deriving an implementation:

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

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

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

Manually implementing:

use std::fmt;

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

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

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

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

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

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

Pretty-printing with #?:

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

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

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

Required methods

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

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 TcpListener[src]

impl Debug for ExitCode[src]

impl<'a> Debug for Incoming<'a>[src]

impl<'a> Debug for SocketAncillary<'a>[src]

impl Debug for SocketAddr[src]

impl Debug for FromVecWithNulError[src]

impl<B> Debug for Lines<B> where
    B: Debug
[src]

impl Debug for RecvTimeoutError[src]

impl<B> Debug for Split<B> where
    B: Debug
[src]

impl Debug for Output[src]

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

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

impl Debug for Sink[src]

impl Debug for DefaultHasher[src]

impl<'_> Debug for StdinLock<'_>[src]

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

impl Debug for Args[src]

impl Debug for VarError[src]

impl Debug for ArgsOs[src]

impl Debug for OsStr[src]

impl Debug for UnixDatagram[src]

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

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

impl<'a> Debug for Ancestors<'a>[src]

impl Debug for ThreadId[src]

impl Debug for SocketAddrV4[src]

impl Debug for NulError[src]

impl Debug for ChildStdin[src]

impl Debug for DirEntry[src]

impl Debug for SocketAddr[src]

impl Debug for CString[src]

impl Debug for Builder[src]

impl Debug for ExitStatus[src]

impl<T> Debug for Key<T>[src]

impl Debug for BarrierWaitResult[src]

impl Debug for IpAddr[src]

impl<T> Debug for Cursor<T> where
    T: Debug
[src]

impl<T> Debug for TryLockError<T>[src]

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

impl Debug for ErrorKind[src]

impl Debug for Condvar[src]

impl<T> Debug for JoinHandle<T>[src]

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

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

impl Debug for Metadata[src]

impl<'_> Debug for SplitPaths<'_>[src]

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

impl<W> Debug for BufWriter<W> where
    W: Write + Debug
[src]

impl<T> Debug for SyncOnceCell<T> where
    T: Debug
[src]

impl Debug for Backtrace[src]

impl<K, V> Debug for IntoValues<K, V> where
    V: Debug
[src]

impl Debug for TcpStream[src]

impl<'a> Debug for Incoming<'a>[src]

impl Debug for Command[src]

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

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

impl Debug for AddrParseError[src]

impl Debug for Vars[src]

impl Debug for Ipv4Addr[src]

impl Debug for Empty[src]

impl Debug for RecvError[src]

impl Debug for Instant[src]

impl<'a> Debug for CommandEnvs<'a>[src]

impl Debug for BacktraceStatus[src]

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

impl<K> Debug for IntoIter<K> where
    K: Debug
[src]

impl Debug for SocketAddrV6[src]

impl<'a> Debug for CommandArgs<'a>[src]

impl<'_> Debug for StdoutLock<'_>[src]

impl Debug for FileType[src]

impl<T> Debug for IntoIter<T> where
    T: Debug
[src]

impl<'a> Debug for Chain<'a>[src]

impl<T, S> Debug for HashSet<T, S> where
    T: Debug
[src]

impl<R> Debug for BufReader<R> where
    R: Debug
[src]

impl Debug for ReadDir[src]

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

impl<K, V> Debug for IntoKeys<K, V> where
    K: Debug
[src]

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

impl Debug for SystemTimeError[src]

impl<T> Debug for TrySendError<T>[src]

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

impl<T> Debug for Receiver<T>[src]

impl Debug for System[src]

impl<'a> Debug for IoSliceMut<'a>[src]

impl Debug for ChildStdout[src]

impl Debug for Stdin[src]

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

impl<T> Debug for Sender<T>[src]

impl Debug for Child[src]

impl<T> Debug for AssertUnwindSafe<T> where
    T: Debug
[src]

impl Debug for StripPrefixError[src]

impl<'a> Debug for PrefixComponent<'a>[src]

impl Debug for PathBuf[src]

impl Debug for IntoStringError[src]

impl Debug for UCred[src]

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

impl Debug for Path[src]

impl Debug for Stdio[src]

impl<'a> Debug for Prefix<'a>[src]

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

impl Debug for Ipv6Addr[src]

impl<'_> Debug for Iter<'_>[src]

impl Debug for WaitTimeoutResult[src]

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

impl Debug for VarsOs[src]

impl Debug for Stdout[src]

impl Debug for UdpSocket[src]

impl Debug for UnixStream[src]

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

impl<T, F> Debug for SyncLazy<T, F> where
    T: Debug
[src]

impl Debug for Ipv6MulticastScope[src]

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

impl<'a> Debug for IoSlice<'a>[src]

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug
[src]

impl Debug for SeekFrom[src]

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

impl Debug for Repeat[src]

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

impl Debug for JoinPathsError[src]

impl Debug for Thread[src]

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

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

impl<T> Debug for Mutex<T> where
    T: Debug + ?Sized
[src]

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

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

impl Debug for DirBuilder[src]

impl<'_> Debug for Display<'_>[src]

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug
[src]

impl Debug for OnceState[src]

impl Debug for Permissions[src]

impl<T> Debug for PoisonError<T>[src]

impl Debug for OsString[src]

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

impl Debug for Once[src]

impl Debug for AncillaryError[src]

impl<T> Debug for SendError<T>[src]

impl<T> Debug for SyncSender<T>[src]

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

impl<W> Debug for IntoInnerError<W> where
    W: Debug
[src]

impl<W> Debug for LineWriter<W> where
    W: Write + Debug
[src]

impl Debug for Stderr[src]

impl<T> Debug for RwLock<T> where
    T: Debug + ?Sized
[src]

impl Debug for RandomState[src]

impl Debug for Initializer[src]

impl<R> Debug for Bytes<R> where
    R: Debug
[src]

impl Debug for ChildStderr[src]

impl Debug for UnixListener[src]

impl Debug for Error[src]

impl Debug for File[src]

impl Debug for TryRecvError[src]

impl Debug for SystemTime[src]

impl<T> Debug for Take<T> where
    T: Debug
[src]

impl<'_> Debug for StderrLock<'_>[src]

impl Debug for OpenOptions[src]

impl<'_> Debug for Components<'_>[src]

impl Debug for Shutdown[src]

impl<T> Debug for Key<T>[src]

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

impl Debug for FromBytesWithNulError[src]

impl Debug for Barrier[src]

impl Debug for CStr[src]

impl Debug for AccessError[src]

impl<'a> Debug for Component<'a>[src]

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

impl Debug for Ordering[src]

impl Debug for __m256[src]

impl Debug for FpCategory[src]

impl<T> Debug for OnceCell<T> where
    T: Debug
[src]

impl Debug for EscapeDebug[src]

impl<T> Debug for Option<T> where
    T: Debug
[src]

impl Debug for NonZeroU16[src]

impl Debug for BorrowMutError[src]

impl<T> Debug for Empty<T>[src]

impl Debug for DecodeUtf16Error[src]

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

impl Debug for AtomicIsize[src]

impl<'_> Debug for Chars<'_>[src]

impl Debug for isize[src]

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

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

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

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

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

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

impl<F> Debug for RepeatWith<F> where
    F: Debug
[src]

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

impl Debug for u8[src]

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

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

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

impl Debug for __m128d[src]

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

impl Debug for RawWakerVTable[src]

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

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

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[src]

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

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

impl Debug for __m512d[src]

impl<T, F> Debug for Lazy<T, F> where
    T: Debug
[src]

impl<'_> Debug for Context<'_>[src]

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

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[src]

impl<Y, R> Debug for GeneratorState<Y, R> where
    R: Debug,
    Y: Debug
[src]

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[src]

impl Debug for ParseBoolError[src]

impl Debug for AtomicU32[src]

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[src]

impl<'a> Debug for LinesAny<'a>[src]

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

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[src]

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

impl Debug for TryFromSliceError[src]

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

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

impl Debug for i128[src]

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

impl Debug for Utf8Lossy[src]

impl Debug for c_void[src]

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[src]

impl<'a, 'b> Debug for StrSearcher<'a, 'b>[src]

impl<T> Debug for *const T where
    T: ?Sized
[src]

impl Debug for NonZeroI64[src]

impl Debug for NonZeroI128[src]

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

impl Debug for BorrowError[src]

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[src]

impl<I, F> Debug for Map<I, F> where
    I: Debug
[src]

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

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[src]

impl Debug for dyn Any + 'static + Send[src]

impl<I, P> Debug for Filter<I, P> where
    I: Debug
[src]

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

impl Debug for NoneError[src]

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

impl Debug for char[src]

impl Debug for dyn Any + 'static[src]

impl Debug for dyn Any + 'static + Send + Sync[src]

impl Debug for NonZeroIsize[src]

impl<I, P> Debug for TakeWhile<I, P> where
    I: Debug
[src]

impl Debug for u16[src]

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[src]

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

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

impl<T> Debug for Wrapping<T> where
    T: Debug
[src]

impl<T> Debug for RefCell<T> where
    T: Debug + ?Sized
[src]

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

impl Debug for NonZeroUsize[src]

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

impl Debug for EscapeUnicode[src]

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

impl Debug for u32[src]

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

impl<'a> Debug for EscapeUnicode<'a>[src]

impl<'_> Debug for EncodeUtf16<'_>[src]

impl<Idx> Debug for Range<Idx> where
    Idx: Debug
[src]

impl<T> Debug for Poll<T> where
    T: Debug
[src]

impl Debug for CpuidResult[src]

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

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

impl Debug for ![src]

impl<Idx> Debug for RangeInclusive<Idx> where
    Idx: Debug
[src]

impl<'a> Debug for Lines<'a>[src]

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[src]

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

impl<T> Debug for Bound<T> where
    T: Debug
[src]

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[src]

impl Debug for NonZeroI16[src]

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

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

impl<'a> Debug for SplitWhitespace<'a>[src]

impl Debug for f64[src]

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

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

impl<A, B> Debug for Zip<A, B> where
    A: Debug,
    B: Debug
[src]

impl<'a> Debug for Location<'a>[src]

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

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

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

impl<F> Debug for FromFn<F>[src]

impl<T> Debug for UnsafeCell<T> where
    T: Debug + ?Sized
[src]

impl<'f> Debug for VaListImpl<'f>[src]

impl<T> Debug for Cell<T> where
    T: Copy + Debug
[src]

impl Debug for u64[src]

impl Debug for AtomicI16[src]

impl Debug for NonZeroI32[src]

impl<'a> Debug for Utf8LossyChunk<'a>[src]

impl Debug for i8[src]

impl Debug for __m256i[src]

impl Debug for NonZeroU128[src]

impl Debug for NonZeroI8[src]

impl<A> Debug for IntoIter<A> where
    A: Debug
[src]

impl Debug for Layout[src]

impl<B, C> Debug for ControlFlow<B, C> where
    C: Debug,
    B: Debug
[src]

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

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

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

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

impl Debug for __m512[src]

impl<P> Debug for Pin<P> where
    P: Debug
[src]

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

impl Debug for AtomicI64[src]

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

impl<I> Debug for Cloned<I> where
    I: Debug
[src]

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[src]

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

impl Debug for AllocError[src]

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

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

impl<T> Debug for *mut T where
    T: ?Sized
[src]

impl<I> Debug for Enumerate<I> where
    I: Debug
[src]

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[src]

impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>[src]

impl Debug for ParseIntError[src]

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

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[src]

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

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

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

impl Debug for AtomicI32[src]

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

impl Debug for usize[src]

impl<'a> Debug for Bytes<'a>[src]

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

impl<I> Debug for Take<I> where
    I: Debug
[src]

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[src]

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

impl<A> Debug for Repeat<A> where
    A: Debug
[src]

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

impl Debug for ParseFloatError[src]

impl<T> Debug for Rev<T> where
    T: Debug
[src]

impl Debug for f32[src]

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

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

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

impl<I> Debug for StepBy<I> where
    I: Debug
[src]

impl<I> Debug for Cycle<I> where
    I: Debug
[src]

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[src]

impl<H> Debug for BuildHasherDefault<H>[src]

impl Debug for AtomicU64[src]

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

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

impl<'a> Debug for SplitAsciiWhitespace<'a>[src]

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

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

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

impl Debug for TryFromIntError[src]

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

impl<I, F> Debug for Inspect<I, F> where
    I: Debug
[src]

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

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

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[src]

impl Debug for AtomicU8[src]

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[src]

impl<Ret> Debug for fn() -> Ret[src]

impl<T> Debug for NonNull<T> where
    T: ?Sized
[src]

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

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

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[src]

impl<T> Debug for Once<T> where
    T: Debug
[src]

impl Debug for NonZeroU8[src]

impl Debug for bool[src]

impl Debug for Utf8Error[src]

impl<'a> Debug for EscapeDefault<'a>[src]

impl<I, F> Debug for FilterMap<I, F> where
    I: Debug
[src]

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

impl<Ret> Debug for unsafe fn() -> Ret[src]

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

impl Debug for ToUppercase[src]

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

impl Debug for str[src]

impl Debug for __m512i[src]

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[src]

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

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

impl Debug for ToLowercase[src]

impl<'a> Debug for EscapeDebug<'a>[src]

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

impl Debug for ParseCharError[src]

impl Debug for u128[src]

impl<F> Debug for OnceWith<F> where
    F: Debug
[src]

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

impl<Idx> Debug for RangeFrom<Idx> where
    Idx: Debug
[src]

impl Debug for SearchStep[src]

impl<'a> Debug for CharIndices<'a>[src]

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[src]

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

impl Debug for EscapeDefault[src]

impl<I, P> Debug for SkipWhile<I, P> where
    I: Debug
[src]

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

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

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

impl<T> Debug for Ready<T> where
    T: Debug
[src]

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

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

impl<'a> Debug for PanicInfo<'a>[src]

impl<T> Debug for Discriminant<T>[src]

impl<I> Debug for Fuse<I> where
    I: Debug
[src]

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

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

impl<T> Debug for AtomicPtr<T>[src]

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

impl<T> Debug for Pending<T>[src]

impl Debug for Waker[src]

impl Debug for AtomicI8[src]

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

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

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

impl Debug for i32[src]

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

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

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

impl Debug for __m256d[src]

impl<A, B> Debug for Chain<A, B> where
    A: Debug,
    B: Debug
[src]

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

impl Debug for AtomicBool[src]

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

impl Debug for NonZeroU64[src]

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

impl Debug for EscapeDefault[src]

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

impl<F> Debug for PollFn<F>[src]

impl Debug for __m128i[src]

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

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

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
[src]

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

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[src]

impl Debug for AtomicU16[src]

impl Debug for NonZeroU32[src]

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

impl Debug for ()[src]

impl Debug for AtomicUsize[src]

impl Debug for CharTryFromError[src]

impl<'a> Debug for CharSearcher<'a>[src]

impl Debug for LayoutError[src]

impl Debug for RawWaker[src]

impl Debug for Infallible[src]

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

impl Debug for RangeFull[src]

impl Debug for i64[src]

impl Debug for IntErrorKind[src]

impl<Idx> Debug for RangeToInclusive<Idx> where
    Idx: Debug
[src]

impl Debug for Duration[src]

impl Debug for SipHasher[src]

impl<I> Debug for Copied<I> where
    I: Debug
[src]

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

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[src]

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

impl<T> Debug for ManuallyDrop<T> where
    T: Debug + ?Sized
[src]

impl<T> Debug for Reverse<T> where
    T: Debug
[src]

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[src]

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

impl<T> Debug for MaybeUninit<T>[src]

impl<Idx> Debug for RangeTo<Idx> where
    Idx: Debug
[src]

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[src]

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

impl Debug for Ordering[src]

impl<T, F> Debug for Successors<T, F> where
    T: Debug
[src]

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

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

impl Debug for i16[src]

impl Debug for TypeId[src]

impl<I> Debug for Skip<I> where
    I: Debug
[src]

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

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

impl<I, P> Debug for MapWhile<I, P> where
    I: Debug
[src]

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

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

impl Debug for __m128[src]

impl<T> Debug for IntoIterSorted<T> where
    T: Debug
[src]

impl<T> Debug for IntoIter<T> where
    T: Debug
[src]

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

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

impl<T> Debug for BinaryHeap<T> where
    T: Debug
[src]

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

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

impl<T> Debug for IntoIter<T> where
    T: Debug
[src]

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

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

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

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

impl<T, A> Debug for IntoIter<T, A> where
    T: Debug,
    A: Allocator
[src]

impl<K, V> Debug for IntoKeys<K, V> where
    K: Debug
[src]

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

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

impl<'_, T, A> Debug for Drain<'_, T, A> where
    T: Debug,
    A: Allocator
[src]

impl<'_> Debug for Drain<'_>[src]

impl<T> Debug for IntoIter<T> where
    T: Debug
[src]

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

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

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

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

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

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

impl<T> Debug for VecDeque<T> where
    T: Debug
[src]

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

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

impl<T> Debug for Rc<T> where
    T: Debug + ?Sized
[src]

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized
[src]

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

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

impl<T> Debug for LinkedList<T> where
    T: Debug
[src]

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized
[src]

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

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

impl Debug for FromUtf16Error[src]

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

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

impl<K, V> Debug for IntoValues<K, V> where
    V: Debug
[src]

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

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

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

impl Debug for Global[src]

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

impl<T, A> Debug for Box<T, A> where
    T: Debug + ?Sized,
    A: Allocator
[src]

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

impl<K, V> Debug for IntoIter<K, V> where
    K: Debug,
    V: Debug
[src]

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

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a + Debug
[src]

impl<T> Debug for Weak<T> where
    T: Debug + ?Sized
[src]

impl Debug for String[src]

impl<T> Debug for IntoIter<T> where
    T: Debug
[src]

impl<T> Debug for BTreeSet<T> where
    T: Debug
[src]

impl<K, V> Debug for BTreeMap<K, V> where
    K: Debug,
    V: Debug
[src]

impl Debug for TryReserveError[src]

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

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

impl Debug for FromUtf8Error[src]

impl Debug for _Unwind_Reason_Code

impl Debug for WasmMetadata[src]

impl Debug for WasmEntryAttributes[src]

impl Debug for WasmValuesSet[src]

impl Debug for WasmFieldName[src]

impl Debug for WasmValue[src]

impl Debug for WasmLevel[src]