Trait nom::lib::std::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 ).

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

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 VarError

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

impl Debug for Once

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

impl Debug for Stderr

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

impl Debug for SocketAddr

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

impl Debug for Initializer

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 Backtrace

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

impl Debug for FromVecWithNulError

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

impl Debug for Metadata

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

impl Debug for ThreadId

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 ExitStatus

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

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

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

impl Debug for Output

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

impl Debug for Barrier

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

impl Debug for ChildStdout

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

impl<'a> Debug for CommandArgs<'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 Child

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

impl Debug for BarrierWaitResult

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

impl Debug for Instant

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

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

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

impl Debug for NulError

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 ChildStdin

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 Stdin

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

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

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

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

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

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

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

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

impl Debug for JoinPathsError

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

impl Debug for Empty

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

impl Debug for Stdio

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

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

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

impl<T> Debug for SyncSender<T>

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

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

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 UnixDatagram

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

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

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

impl Debug for SocketAddr

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

impl<T> Debug for TryLockError<T>

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

impl Debug for AccessError

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

impl Debug for FromBytesWithNulError

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

impl Debug for PathBuf

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

impl Debug for IntoStringError

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

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

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

impl<T> Debug for Receiver<T>

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

impl<T> Debug for JoinHandle<T>

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

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

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

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

impl Debug for TcpStream

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

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

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

impl Debug for OnceState

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

impl Debug for Args

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

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

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

impl<T> Debug for SendError<T>

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

impl Debug for OpenOptions

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

impl Debug for IpAddr

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

impl Debug for Vars

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

impl Debug for VarsOs

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

impl Debug for ReadDir

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

impl<T> Debug for Sender<T>

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

impl Debug for UnixStream

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

impl Debug for Path

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

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

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

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

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

impl Debug for UdpSocket

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

impl Debug for DirBuilder

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 AddrParseError

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

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

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 SeekFrom

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

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 Repeat

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 BacktraceStatus

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

impl Debug for SystemTime

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

impl Debug for FileType

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

impl Debug for WaitTimeoutResult

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

impl Debug for CString

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

impl Debug for TcpListener

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

impl Debug for Condvar

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

impl Debug for ErrorKind

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 SystemTimeError

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

impl Debug for ExitCode

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

impl Debug for OsString

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

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

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

impl Debug for SocketAddrV6

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

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

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

impl Debug for Stdout

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

impl Debug for Shutdown

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

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

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 OsStr

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

impl<T> Debug for Cursor<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 Debug for File

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

impl Debug for RecvTimeoutError

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

impl Debug for Ipv6MulticastScope

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

impl Debug for UCred

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

impl Debug for RecvError

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

impl Debug for StripPrefixError

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

impl Debug for Builder

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

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

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

impl<'a> Debug for Chain<'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 Sink

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

impl Debug for Ipv4Addr

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

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

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

impl Debug for SocketAddrV4

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

impl Debug for DirEntry

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

impl Debug for TryRecvError

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

impl Debug for ChildStderr

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

impl Debug for UnixListener

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

impl Debug for ArgsOs

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

impl Debug for Ipv6Addr

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

impl Debug for Error

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

impl Debug for CStr

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

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

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

impl Debug for AtomicIsize

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

impl Debug for NonZeroI64

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

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

impl Debug for __m128

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

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

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

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

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

impl Debug for u8

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

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

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

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

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

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

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

impl Debug for AtomicUsize

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

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

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

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

impl Debug for AtomicI128

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

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

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 i64

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

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

impl Debug for CpuidResult

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

impl Debug for Waker

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<F> Debug for PollFn<F>

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

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

impl Debug for PhantomPinned

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

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

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

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

impl Debug for NonZeroI32

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

impl Debug for AtomicU128

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

impl Debug for NonZeroU32

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

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

impl Debug for i128

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

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

impl Debug for __m256d

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

impl Debug for u16

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

impl Debug for AtomicU16

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

impl Debug for EscapeDefault

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

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

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

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

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

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

impl Debug for BorrowMutError

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

impl Debug for RawWaker

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

impl Debug for AtomicI16

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

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

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

impl<Ret, A> Debug for unsafe fn(A) -> 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<T> Debug for *const T where
    T: ?Sized, 

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

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

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

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

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

impl Debug for !

fn fmt(&self, &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 str

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

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

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

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

impl Debug for __m128d

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

impl Debug for AtomicI8

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

impl Debug for dyn Any + 'static + Send

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

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

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

impl Debug for CharTryFromError

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

impl Debug for ToUppercase

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

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

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

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

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

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

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

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

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

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 i32

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

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

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

impl Debug for NonZeroU8

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

impl Debug for AtomicI32

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

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

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

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

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

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

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

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

impl Debug for Duration

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 u128

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

impl Debug for char

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

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

impl Debug for c_void

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

impl Debug for DecodeUtf16Error

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

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

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

impl Debug for NonZeroU64

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

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

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

impl Debug for f32

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

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

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

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

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

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

impl Debug for i8

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

impl Debug for EscapeUnicode

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

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

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

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

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

impl Debug for NonZeroU128

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

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

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

impl Debug for ()

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

impl Debug for EscapeDebug

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

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

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

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

impl Debug for TryFromIntError

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 RawWakerVTable

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

impl Debug for NonZeroI8

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

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

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

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

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

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

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

impl Debug for __m512

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

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

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

impl Debug for Utf8Lossy

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

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

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

impl<Ret, A, B, C, 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 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, 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 ParseFloatError

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

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

impl Debug for NonZeroIsize

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

impl Debug for IntErrorKind

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

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

impl Debug for AtomicU64

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

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

impl Debug for NonZeroI16

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

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

impl Debug for __m128i

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

impl Debug for dyn Any + 'static

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

impl<Ret, A, B, C, D, E, F, G> 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 PanicInfo<'a>

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

impl Debug for u64

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<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<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<Ret> Debug for unsafe fn() -> 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, const N: usize> Debug for [T; N] where
    T: Debug, 

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

impl Debug for AtomicU8

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

impl Debug for TypeId

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

impl Debug for bool

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

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

impl Debug for TryFromSliceError

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

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

impl Debug for AtomicI64

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

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

impl Debug for u32

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, 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 AtomicBool

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 isize

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

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

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

impl Debug for Ordering

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

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

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

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

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 Arc<T> where
    T: Debug + ?Sized, 

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

impl Debug for _Unwind_Reason_Code

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

impl<R> Debug for BitMask<R> where
    R: BitRegister, 

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

impl<O, V> Debug for BitArray<O, V> where
    O: BitOrder,
    V: BitView, 

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

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

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

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

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

impl<'a, O, T> Debug for RChunksExactMut<'a, O, T> where
    O: Debug + BitOrder,
    T: Debug + 'a + BitStore,
    <T as BitStore>::Alias: Debug, 

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

impl<R> Debug for BitTail<R> where
    R: BitRegister, 

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

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

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

impl<'a, O, T> Debug for BitDomain<'a, O, T> where
    O: Debug + BitOrder,
    T: Debug + 'a + BitStore,
    <T as BitStore>::Mem: Debug, 

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

impl<O, T> Debug for BitVec<O, T> where
    O: BitOrder,
    T: BitStore, 

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

impl Debug for Msb0

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

impl<'a, O, T> Debug for BitDomainMut<'a, O, T> where
    O: Debug + BitOrder,
    T: Debug + 'a + BitStore,
    <T as BitStore>::Mem: Debug, 

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

impl<'a, O, T> Debug for RChunksMut<'a, O, T> where
    O: Debug + BitOrder,
    T: Debug + 'a + BitStore,
    <T as BitStore>::Alias: Debug, 

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

impl<'a, O, T> Debug for IterMut<'a, O, T> where
    O: Debug + 'a + BitOrder,
    T: Debug + 'a + BitStore,
    <T as BitStore>::Alias: Debug, 

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

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

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

impl<'a, O, T> Debug for ChunksMut<'a, O, T> where
    O: Debug + BitOrder,
    T: Debug + 'a + BitStore,
    <T as BitStore>::Alias: Debug, 

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

impl<'_, O, T> Debug for BitMut<'_, O, T> where
    O: BitOrder,
    T: BitStore, 

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

impl<R> Debug for BitIdx<R> where
    R: BitRegister, 

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

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

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

impl<R> Debug for BitSel<R> where
    R: BitRegister, 

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

impl<'a, O, T> Debug for Drain<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore, 

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

impl<'a, O, T> Debug for Iter<'a, O, T> where
    O: Debug + 'a + BitOrder,
    T: Debug + 'a + BitStore,
    <T as BitStore>::Mem: Debug, 

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

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

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

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

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

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

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

impl<O, T> Debug for IntoIter<O, T> where
    O: Debug + 'static + BitOrder,
    T: Debug + 'static + BitStore, 

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

impl Debug for Lsb0

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

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

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

impl<'a, T> Debug for Domain<'a, T> where
    T: Debug + 'a + BitStore,
    <T as BitStore>::Mem: Debug, 

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

impl<'a, T> Debug for DomainMut<'a, T> where
    T: Debug + 'a + BitStore,
    <T as BitStore>::Mem: Debug,
    <T as BitStore>::Alias: Debug, 

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

impl<'a, O, T> Debug for ChunksExactMut<'a, O, T> where
    O: Debug + BitOrder,
    T: Debug + 'a + BitStore,
    <T as BitStore>::Alias: Debug, 

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

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

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

impl<O, T> Debug for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

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

impl<O, T> Debug for BitBox<O, T> where
    O: BitOrder,
    T: BitStore, 

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

impl<'a, O, T, I> Debug for Splice<'a, O, T, I> where
    I: Debug + Iterator<Item = bool>,
    O: Debug + BitOrder,
    T: Debug + 'a + BitStore, 

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

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

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

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

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

impl<R> Debug for BitPos<R> where
    R: BitRegister, 

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

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

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

impl<T> Debug for FmtUpperExp<T> where
    T: UpperExp, 

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

impl<T> Debug for FmtPointer<T> where
    T: Pointer, 

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

impl<T> Debug for FmtUpperHex<T> where
    T: UpperHex, 

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

impl<T> Debug for FmtBinary<T> where
    T: Binary, 

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

impl<T> Debug for FmtOctal<T> where
    T: Octal, 

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

impl<T> Debug for FmtLowerExp<T> where
    T: LowerExp, 

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

impl<T> Debug for FmtDisplay<T> where
    T: Display, 

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

impl<T> Debug for FmtLowerHex<T> where
    T: LowerHex, 

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

impl Debug for ErrorCode

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

impl Debug for Error

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

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> + Copy, 

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

impl Debug for CaptureLocations

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 SetMatches

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

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

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 CaptureLocations

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<'t> Debug for Match<'t>

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

impl Debug for Regex

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

Shows the original regular expression.

impl<'a, R> Debug for ReplacerRef<'a, R> where
    R: 'a + Debug + ?Sized, 

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 RegexSet

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

impl Debug for Error

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

impl Debug for ErrorKind

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

impl<S> Debug for AhoCorasick<S> where
    S: StateID + Debug, 

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

impl Debug for Match

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

impl Debug for Config

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

impl Debug for MatchKind

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

impl Debug for Builder

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

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

impl<'s, 'h> Debug for FindIter<'s, 'h>

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

impl<'a, R, S> Debug for StreamFindIter<'a, R, S> where
    R: Debug,
    S: 'a + StateID + Debug, 

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

impl Debug for Searcher

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

impl Debug for MatchKind

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

impl Debug for Error

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

impl Debug for AhoCorasickBuilder

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

impl Debug for ClassSetRange

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

impl Debug for Repetition

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

impl Debug for SpecialLiteralKind

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

impl Debug for Literal

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

impl Debug for ClassSetItem

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

impl Debug for Anchor

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

impl Debug for LiteralKind

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

impl Debug for Span

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

impl Debug for Literal

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

impl Debug for HexLiteralKind

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

impl Debug for FlagsItemKind

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

impl Debug for RepetitionKind

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

impl Debug for UnicodeWordError

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

impl Debug for ClassAscii

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

impl Debug for ErrorKind

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

impl Debug for Flags

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

impl Debug for FlagsItem

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

impl Debug for GroupKind

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

impl Debug for ClassPerlKind

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

impl Debug for Ast

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

impl Debug for ClassSet

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

impl Debug for Parser

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

impl Debug for ClassAsciiKind

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

impl Debug for ParserBuilder

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

impl Debug for ClassPerl

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

impl Debug for ClassBytes

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 ClassUnicodeOpKind

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

impl Debug for ClassBracketed

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

impl Debug for ClassUnicodeKind

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

impl Debug for Utf8Sequence

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

impl Debug for ClassBytesRange

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

impl Debug for Utf8Range

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

impl Debug for Literals

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

impl Debug for ClassSetBinaryOp

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

impl Debug for RepetitionKind

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

impl Debug for Class

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

impl Debug for AssertionKind

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

impl Debug for Translator

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

impl Debug for RepetitionRange

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

impl Debug for CaptureName

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

impl Debug for Alternation

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

impl Debug for WithComments

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

impl Debug for Position

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

impl Debug for Parser

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

impl Debug for ClassUnicodeRange

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

impl Debug for ClassUnicode

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

impl Debug for RepetitionRange

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

impl Debug for ParserBuilder

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

impl Debug for Class

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

impl Debug for HirKind

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

impl Debug for Repetition

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

impl Debug for ErrorKind

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

impl Debug for Concat

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

impl Debug for Group

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 ClassSetUnion

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

impl Debug for CaseFoldError

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

impl Debug for Literal

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

impl Debug for Flag

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

impl Debug for Comment

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

impl Debug for RepetitionOp

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

impl Debug for Hir

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

impl Debug for Group

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

impl Debug for Error

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

impl Debug for ClassSetBinaryOpKind

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

impl Debug for Assertion

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

impl Debug for Error

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

impl Debug for Error

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

impl Debug for ClassUnicode

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

impl Debug for Printer

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

impl Debug for Printer

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

impl Debug for WordBoundary

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 SetFlags

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<T> Debug for ThreadLocal<T> where
    T: Send + Debug, 

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

Loading content...

Implementors

impl Debug for CompareResult

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

impl Debug for Needed

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

impl Debug for nom::error::ErrorKind

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

impl Debug for VerboseErrorKind

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

impl Debug for nom::lib::std::cmp::Ordering

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

impl Debug for TryReserveError

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

impl Debug for Infallible

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

impl Debug for Alignment

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

impl Debug for SearchStep

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

impl Debug for Endianness

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

impl Debug for AllocError

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

impl Debug for Global

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

impl Debug for Layout

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

impl Debug for LayoutErr

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

impl Debug for System

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

impl Debug for DefaultHasher

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

impl Debug for RandomState

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

impl Debug for nom::lib::std::fmt::Error

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

impl Debug for SipHasher

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

impl Debug for RangeFull

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

impl Debug for NoneError

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

impl Debug for String

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

impl Debug for ParseBoolError

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

impl Debug for Utf8Error

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

impl Debug for FromUtf8Error

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

impl Debug for FromUtf16Error

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

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

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

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

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

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

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

impl<'_> Debug for nom::lib::std::string::Drain<'_>

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

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

impl<'_, K> Debug for nom::lib::std::collections::hash_set::Drain<'_, K> where
    K: Debug, 

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

impl<'_, K> Debug for nom::lib::std::collections::hash_set::Iter<'_, K> where
    K: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::btree_map::Entry<'_, K, V> where
    K: Ord + Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::Entry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::btree_map::Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::btree_map::Keys<'_, K, V> where
    K: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::btree_map::OccupiedEntry<'_, K, V> where
    K: Ord + Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::btree_map::Range<'_, K, V> where
    K: Debug,
    V: Debug, 

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

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

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

impl<'_, K, V> Debug for nom::lib::std::collections::btree_map::VacantEntry<'_, K, V> where
    K: Ord + Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::btree_map::Values<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::btree_map::ValuesMut<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::Keys<'_, K, V> where
    K: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::OccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::VacantEntry<'_, K, V> where
    K: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::Values<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V> Debug for nom::lib::std::collections::hash_map::ValuesMut<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V, F> Debug for nom::lib::std::collections::btree_map::DrainFilter<'_, K, V, F> where
    F: FnMut(&K, &mut V) -> bool,
    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 RawEntryBuilder<'_, 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<'_, K, V, S> Debug for RawOccupiedEntryMut<'_, K, V, S> where
    K: Debug,
    V: Debug, 

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

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

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

impl<'_, T> Debug for nom::lib::std::collections::binary_heap::Iter<'_, T> where
    T: Debug, 

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

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

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

impl<'_, T> Debug for nom::lib::std::collections::btree_set::Difference<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::btree_set::Intersection<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::btree_set::Iter<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::btree_set::SymmetricDifference<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::btree_set::Union<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::linked_list::Cursor<'_, T> where
    T: Debug, 

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

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

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

impl<'_, T> Debug for nom::lib::std::collections::linked_list::Iter<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::linked_list::IterMut<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::vec_deque::Drain<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::vec_deque::Iter<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::collections::vec_deque::IterMut<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::slice::Iter<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::slice::IterMut<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for nom::lib::std::vec::Drain<'_, T> where
    T: Debug, 

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

impl<'_, T, F> Debug for nom::lib::std::collections::btree_set::DrainFilter<'_, T, F> where
    F: FnMut(&T) -> bool,
    T: Debug, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'_, T, S> Debug for nom::lib::std::collections::hash_set::Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, T, S> Debug for nom::lib::std::collections::hash_set::Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, T, S> Debug for nom::lib::std::collections::hash_set::SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, T, S> Debug for nom::lib::std::collections::hash_set::Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

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

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

impl<'a> Debug for nom::lib::std::str::Bytes<'a>

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

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

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

impl<'a> Debug for nom::lib::std::str::EscapeDebug<'a>

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

impl<'a> Debug for nom::lib::std::str::EscapeDefault<'a>

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

impl<'a> Debug for nom::lib::std::str::EscapeUnicode<'a>

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

impl<'a> Debug for nom::lib::std::str::Lines<'a>

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

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

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

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

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

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

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

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

impl<'a, A> Debug for nom::lib::std::option::Iter<'a, A> where
    A: 'a + Debug, 

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

impl<'a, A> Debug for nom::lib::std::option::IterMut<'a, A> where
    A: 'a + Debug, 

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

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

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

impl<'a, K, F> Debug for nom::lib::std::collections::hash_set::DrainFilter<'a, K, F> where
    F: FnMut(&K) -> bool, 

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

impl<'a, K, V> Debug for nom::lib::std::collections::btree_map::IterMut<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

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

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

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

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

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

impl<'a, 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<'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<'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<'a, P> Debug for nom::lib::std::str::RSplit<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl<'a, P> Debug for nom::lib::std::str::RSplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

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

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

impl<'a, P> Debug for nom::lib::std::str::Split<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

impl<'a, P> Debug for nom::lib::std::str::SplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

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

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

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

impl<'a, T> Debug for nom::lib::std::collections::binary_heap::Drain<'a, T> where
    T: 'a + 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<'a, T> Debug for nom::lib::std::collections::btree_set::Range<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::result::Iter<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::result::IterMut<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::Chunks<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::ChunksExact<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::ChunksExactMut<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::ChunksMut<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::RChunks<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::RChunksExact<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::RChunksExactMut<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::RChunksMut<'a, T> where
    T: 'a + Debug, 

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

impl<'a, T> Debug for nom::lib::std::slice::Windows<'a, T> where
    T: 'a + Debug, 

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

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

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

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

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

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

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

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

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

impl<A> Debug for nom::lib::std::iter::Repeat<A> where
    A: Debug, 

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

impl<A> Debug for nom::lib::std::option::IntoIter<A> where
    A: Debug, 

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

impl<A, B> Debug for nom::lib::std::iter::Chain<A, B> where
    A: Debug,
    B: Debug, 

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

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

impl<E: Debug> Debug for Err<E>

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

impl<F> Debug for FromFn<F>

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

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

impl<H> Debug for BuildHasherDefault<H>

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

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

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

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

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

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

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

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

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

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

impl<I> Debug for nom::lib::std::iter::Take<I> where
    I: 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<I, F> Debug for Inspect<I, F> where
    I: Debug, 

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

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

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

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

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<I, St, F> Debug for Scan<I, St, F> where
    I: Debug,
    St: Debug, 

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

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

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

impl<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<I: Debug> Debug for nom::error::Error<I>

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

impl<I: Debug> Debug for VerboseError<I>

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

impl<Idx> Debug for nom::lib::std::ops::Range<Idx> where
    Idx: Debug, 

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

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

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

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

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

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

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

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

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

impl<K> Debug for nom::lib::std::collections::hash_set::IntoIter<K> where
    K: Debug, 

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

impl<K, V> Debug for nom::lib::std::collections::btree_map::IntoIter<K, V> where
    K: Debug,
    V: Debug, 

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

impl<K, V> Debug for nom::lib::std::collections::btree_map::IntoKeys<K, V> where
    K: Debug, 

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

impl<K, V> Debug for nom::lib::std::collections::btree_map::IntoValues<K, V> where
    V: Debug, 

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

impl<K, V> Debug for nom::lib::std::collections::hash_map::IntoIter<K, V> where
    K: Debug,
    V: Debug, 

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

impl<K, V> Debug for nom::lib::std::collections::hash_map::IntoKeys<K, V> where
    K: Debug, 

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

impl<K, V> Debug for nom::lib::std::collections::hash_map::IntoValues<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<K, V, S> Debug for HashMap<K, V, S> where
    K: Debug,
    V: Debug, 

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

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

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

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

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> Debug for nom::lib::std::collections::binary_heap::IntoIter<T> where
    T: Debug, 

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

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

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

impl<T> Debug for nom::lib::std::collections::btree_set::IntoIter<T> where
    T: Debug, 

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

impl<T> Debug for nom::lib::std::collections::linked_list::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 BinaryHeap<T> where
    T: Debug, 

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

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

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

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

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

impl<T> Debug for nom::lib::std::collections::vec_deque::IntoIter<T> where
    T: Debug, 

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

impl<T> Debug for nom::lib::std::iter::Empty<T>

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

impl<T> Debug for nom::lib::std::iter::Once<T> where
    T: Debug, 

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

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

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

impl<T> Debug for Discriminant<T>

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

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

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

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

impl<T> Debug for nom::lib::std::result::IntoIter<T> where
    T: Debug, 

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

impl<T> Debug for nom::lib::std::vec::IntoIter<T> where
    T: Debug, 

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

impl<T> Debug for MaybeUninit<T>

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

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

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

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

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

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

Loading content...