Trait twilio_async::fmt::Debug

#[lang = "debug_trait"]
pub trait Debug {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error>;
}

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Examples

Deriving an implementation:

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

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

println!("The origin is: {:?}", origin);

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 {
        write!(f, "Point {{ x: {}, y: {} }}", self.x, self.y)
    }
}

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

println!("The origin is: {:?}", origin);

This outputs:

The origin is: Point { x: 0, y: 0 }

There are a number of debug_* methods on Formatter 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 };

println!("The origin is: {:#?}", origin);

This outputs:

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 {
        write!(f, "({:?}, {:?})", self.longitude, self.latitude)
    }
}

assert_eq!("(1.987, 2.983)".to_owned(),
           format!("{:?}", Position { longitude: 1.987, latitude: 2.983, }));

Loading content...

Implementations on Foreign Types

impl<'a> Debug for Components<'a>

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

impl Debug for PathBuf

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

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

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

impl Debug for CString

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

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

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

impl Debug for Shutdown

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

impl Debug for WaitTimeoutResult

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

impl Debug for TcpStream

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

impl Debug for ThreadId

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

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

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

impl Debug for SocketAddr

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

impl Debug for AccessError

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

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

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

impl Debug for UnixDatagram

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

impl Debug for CStr

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

impl Debug for TcpListener

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

impl Debug for Builder

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

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

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

impl Debug for NulError

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

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

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

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

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

impl Debug for ExitStatus

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

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

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

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

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

impl<T> Debug for Sender<T>

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

impl Debug for Barrier

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

impl Debug for OsString

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

impl Debug for FileType

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

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

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

impl Debug for OsStr

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

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

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

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

fn fmt(&self, f: &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 ChildStdout

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

impl Debug for Stdio

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

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

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

impl Debug for FromBytesWithNulError

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

impl Debug for UnixStream

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

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

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

impl<T> Debug for Key<T>

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

impl Debug for VarsOs

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

impl Debug for Thread

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 UdpSocket

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

impl Debug for SocketAddr

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

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

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

impl Debug for IntoStringError

fn fmt(&self, f: &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<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

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

impl Debug for Permissions

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

impl<T> Debug for PoisonError<T>

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

impl Debug for DefaultHasher

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

impl Debug for DirBuilder

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

impl Debug for SocketAddrV6

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

impl Debug for AddrParseError

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

impl Debug for UnixListener

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

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

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

impl Debug for Ipv4Addr

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

impl Debug for TryRecvError

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

impl<T, S> Debug for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash + Debug, 

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

impl Debug for JoinPathsError

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

impl Debug for RecvTimeoutError

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

impl<T> Debug for Receiver<T>

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

impl Debug for ExitCode

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

impl<'a> Debug for SplitPaths<'a>

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

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

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

impl Debug for ChildStderr

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<'a, K, V> Debug for OccupiedEntry<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

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

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

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 Path

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

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

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

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

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

impl Debug for SystemTime

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

impl<T> Debug for TryLockError<T>

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

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

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

impl Debug for BarrierWaitResult

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

impl<'a> Debug for Iter<'a>

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

impl Debug for RecvError

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

impl<T> Debug for JoinHandle<T>

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

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

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

impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Eq + Hash + Debug,
    S: BuildHasher,
    V: Debug, 

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

impl Debug for SystemTimeError

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

impl Debug for ReadDir

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

impl Debug for OnceState

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

impl Debug for IpAddr

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

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

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

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

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

impl<'rx, T> Debug for Handle<'rx, T> where
    T: 'rx + Send, 

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 Select

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

impl<'a> Debug for Display<'a>

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

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

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

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

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

impl Debug for RandomState

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

impl Debug for StripPrefixError

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 DirEntry

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

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

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

impl Debug for ChildStdin

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

impl Debug for Ipv6MulticastScope

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

impl Debug for Condvar

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

impl Debug for System

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

impl Debug for Instant

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

impl Debug for Output

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

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

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

impl<T> Debug for TrySendError<T>

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

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

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

impl Debug for VarError

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 Vars

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

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

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

impl Debug for Child

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

impl Debug for File

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

impl Debug for Metadata

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

impl Debug for Args

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

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

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

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

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

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

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

impl Debug for Once

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

impl Debug for SocketAddrV4

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

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

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

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

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

impl Debug for ParseFloatError

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

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

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

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

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

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

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

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

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

impl Debug for u8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for u32

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

impl Debug for ToUppercase

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

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

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

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

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

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

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

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

impl<H> Debug for BuildHasherDefault<H>

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

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

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

impl Debug for Layout

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

impl Debug for NonZeroU8

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

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

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

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

impl Debug for NonZeroU16

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

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, 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, 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<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

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

impl<Ret, A, B, C, D, E, F, G, H, I, 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<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<T> Debug for AtomicPtr<T>

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

impl<I, U> Debug for Flatten<I> where
    I: Iterator + Debug,
    U: Iterator + Debug,
    <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<T> Debug for [T; 32] where
    T: Debug, 

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

impl Debug for AtomicI8

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

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

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

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

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

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

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

impl Debug for NonZeroI128

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

impl Debug for NonZeroI64

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

impl Debug for ParseIntError

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

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

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

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

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

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

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

impl Debug for NonZeroUsize

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

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

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

impl Debug for Utf8Error

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

impl Debug for dyn Any + 'static

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

impl Debug for usize

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

impl<'a> Debug for VaList<'a>

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Ordering

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

impl Debug for SipHasher

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

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

impl Debug for u128

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

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

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

impl Debug for Ordering

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 PhantomPinned

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

impl Debug for f64

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

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, 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<T> Debug for Empty<T>

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

impl Debug for bool

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

impl Debug for RangeFull

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

impl Debug for __m128d

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

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

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

impl Debug for NonZeroI32

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicU32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> Debug for [T; 3] where
    T: 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 Debug for NoneError

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

impl Debug for __m128

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

impl Debug for u64

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> 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<'a, T> Debug for ChunksExact<'a, T> where
    T: 'a + Debug, 

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

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

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

impl Debug for __m512i

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

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

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

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

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

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

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

impl<St, F> Debug for Unfold<St, F> where
    St: Debug, 

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

impl Debug for isize

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, 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<T> Debug for [T] where
    T: 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 Debug for ToLowercase

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

impl Debug for c_void

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

impl Debug for Utf8Lossy

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

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

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

impl Debug for i8

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

impl Debug for AtomicI32

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

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

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

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

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

impl Debug for DecodeUtf16Error

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

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

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 i32

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

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

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

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

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

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

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

impl Debug for Excess

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

impl Debug for AtomicU64

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

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

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

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

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

impl Debug for NonZeroI8

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

impl Debug for NonZeroIsize

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

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

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

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

fn fmt(&self, fmt: &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<'_, T> Debug for IterMut<'_, T> where
    T: Debug, 

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

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

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

impl<Ret, 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: Debug,
    T1: Debug,
    T10: Debug,
    T11: Debug + ?Sized,
    T2: Debug,
    T3: Debug,
    T4: Debug,
    T5: Debug,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug, 

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

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

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

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

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

impl Debug for __m512d

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

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

impl Debug for __m512

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

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

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

impl Debug for ParseBoolError

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

impl<'a> Debug for Chars<'a>

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

impl Debug for EscapeDefault

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

impl Debug for __m128i

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

impl Debug for Waker

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

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

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

impl<T> Debug for [T; 28] where
    T: 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<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 i128

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

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

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

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

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

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

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

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

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

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

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

impl Debug for UnicodeVersion

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

impl Debug for AtomicIsize

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

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

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

impl<Ret, A> 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> 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<T> Debug for Once<T> where
    T: Debug, 

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

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

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

impl Debug for SearchStep

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for str

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

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

impl Debug for Duration

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

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

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

impl Debug for FpCategory

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

impl Debug for NonZeroU128

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> Debug for [T; 23] 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 [T; 2] where
    T: 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<Ret, A, B, C, D, E, F, G, H, I> Debug for fn(A, B, C, D, E, F, G, H, I) -> Ret

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

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

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

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

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

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

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

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

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

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

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

impl Debug for __m64

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

impl Debug for LayoutErr

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

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

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

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

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

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 AllocErr

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for 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<'a> Debug for SplitWhitespace<'a>

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicUsize

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

impl Debug for i64

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 TryFromSliceError

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

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

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

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

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

impl Debug for EscapeDebug

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

impl Debug for u16

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

impl Debug for __m256

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

impl Debug for ()

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

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

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

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

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

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

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 NonZeroU32

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

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

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

impl Debug for AtomicBool

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

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

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

impl Debug for NonZeroU64

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

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

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

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

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

impl Debug for CannotReallocInPlace

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

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

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

impl Debug for NonZeroI16

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

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

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

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

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

impl Debug for char

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

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

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

impl Debug for EscapeDefault

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

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

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

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

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

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

impl Debug for i16

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

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

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

impl Debug for LocalWaker

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for Global

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

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

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

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

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

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

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

impl Debug for FromUtf16Error

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

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

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

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

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

impl Debug for CollectionAllocErr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for String

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

impl<'a> Debug for Drain<'a>

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

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

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

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

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

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

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

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

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

impl Debug for ParseError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for FromUtf8Error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for TryDemangleError

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

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

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

impl Debug for _Unwind_Reason_Code

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

impl Debug for NotifyHandle

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

impl Debug for Run

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

impl<T> Debug for TrySendError<T>

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

impl<S, U, F, St> Debug for WithFlatMap<S, U, F, St> where
    F: Debug + FnMut(U) -> St,
    S: Sink + Debug,
    St: Debug + Stream<Item = <S as Sink>::SinkItem, Error = <S as Sink>::SinkError>,
    U: Debug,
    <S as Sink>::SinkItem: Debug, 

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

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

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

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

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

impl<S, F, U> Debug for OrElse<S, F, U> where
    F: Debug,
    S: Debug,
    U: Debug + IntoFuture,
    <U as IntoFuture>::Future: Debug, 

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

impl<S, E> Debug for FromErr<S, E> where
    E: Debug,
    S: Debug, 

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

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

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

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

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

impl<F> Debug for Execute<F> where
    F: Future + Debug, 

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

impl<T, E> Debug for SendError<T, E>

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

impl<S, F> Debug for Inspect<S, F> where
    F: Debug,
    S: Debug + Stream, 

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

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

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

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

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

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

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

impl<S> Debug for BufferUnordered<S> where
    S: Stream + Debug,
    <S as Stream>::Item: IntoFuture,
    <<S as Stream>::Item as IntoFuture>::Future: Debug, 

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

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

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

impl Debug for Task

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

impl<S, P, R> Debug for TakeWhile<S, P, R> where
    P: Debug,
    R: Debug + IntoFuture,
    S: Debug + Stream,
    <R as IntoFuture>::Future: Debug,
    <S as Stream>::Item: Debug, 

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

impl<S, F> Debug for Filter<S, F> where
    F: Debug,
    S: Debug, 

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

impl<S, U, F, Fut> Debug for With<S, U, F, Fut> where
    F: Debug + FnMut(U) -> Fut,
    Fut: Debug + IntoFuture,
    S: Debug + Sink,
    U: Debug,
    <Fut as IntoFuture>::Future: Debug,
    <S as Sink>::SinkItem: Debug, 

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

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

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

impl<S1, S2> Debug for Chain<S1, S2> where
    S1: Debug,
    S2: Debug, 

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

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

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

impl<I1, I2> Debug for MergedItem<I1, I2> where
    I1: Debug,
    I2: Debug, 

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

impl<T> Debug for SendError<T>

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

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

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

impl<T, E> Debug for Repeat<T, E> where
    E: Debug,
    T: Debug + Clone, 

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

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

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

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

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

impl<I, E> Debug for IterOk<I, E> where
    E: Debug,
    I: Debug, 

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

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

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

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

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

impl<I, E> Debug for SpawnHandle<I, E>

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

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

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

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

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

impl<S> Debug for Chunks<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug,
    <S as Stream>::Error: Debug, 

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

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

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

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

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

impl<S> Debug for Peekable<S> where
    S: Stream + Debug,
    <S as Stream>::Item: Debug, 

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

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

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

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

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

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

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

impl<S, F, U> Debug for AndThen<S, F, U> where
    F: Debug,
    S: Debug,
    U: Debug + IntoFuture,
    <U as IntoFuture>::Future: Debug, 

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

impl<S, F, U> Debug for ForEach<S, F, U> where
    F: Debug,
    S: Debug,
    U: Debug + IntoFuture,
    <U as IntoFuture>::Future: Debug, 

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

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

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

impl Debug for AtomicTask

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

impl<T> Debug for ReuniteError<T>

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

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

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

impl<A, B> Debug for Fanout<A, B> where
    A: Sink + Debug,
    B: Sink + Debug,
    <A as Sink>::SinkItem: Debug,
    <B as Sink>::SinkItem: Debug, 

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

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

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

impl<S> Debug for Buffer<S> where
    S: Sink + Debug,
    <S as Sink>::SinkItem: Debug, 

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

impl<S> Debug for Send<S> where
    S: Sink + Debug,
    <S as Sink>::SinkItem: Debug, 

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

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

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

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

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

impl<S1, S2> Debug for Select<S1, S2> where
    S1: Debug,
    S2: Debug, 

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

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

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

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

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

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

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

impl<S1, S2> Debug for Zip<S1, S2> where
    S1: Stream + Debug,
    S2: Stream + Debug,
    <S1 as Stream>::Item: Debug,
    <S2 as Stream>::Item: Debug, 

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

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

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

impl<S, F> Debug for InspectErr<S, F> where
    F: Debug,
    S: Debug + Stream, 

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

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

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

impl<S, E> Debug for SinkFromErr<S, E> where
    E: Debug,
    S: Debug, 

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

impl<S, F> Debug for MapErr<S, F> where
    F: Debug,
    S: Debug, 

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

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

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

impl<S, F> Debug for SinkMapErr<S, F> where
    F: Debug,
    S: Debug, 

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

impl<T, U> Debug for Forward<T, U> where
    T: Stream + Debug,
    U: Debug,
    <T as Stream>::Item: Debug, 

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

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

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

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

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

impl<S1, S2> Debug for Merge<S1, S2> where
    S1: Debug,
    S2: Stream + Debug,
    <S2 as Stream>::Error: Debug, 

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

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

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

impl<S, F, U> Debug for Then<S, F, U> where
    F: Debug,
    S: Debug,
    U: Debug + IntoFuture,
    <U as IntoFuture>::Future: Debug, 

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

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

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

impl<T> Debug for SendError<T>

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

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

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

impl<S> Debug for Concat<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

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

impl<S, F, Fut, T> Debug for Fold<S, F, Fut, T> where
    F: Debug,
    Fut: Debug + IntoFuture,
    S: Debug,
    T: Debug,
    <Fut as IntoFuture>::Future: Debug, 

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

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

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

impl<I, E> Debug for SpawnHandle<I, E>

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

impl<F> Debug for Execute<F> where
    F: Future + Debug, 

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

impl<T, F, Fut> Debug for Unfold<T, F, Fut> where
    F: Debug,
    Fut: Debug + IntoFuture,
    T: Debug,
    <Fut as IntoFuture>::Future: Debug, 

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

impl<S> Debug for Flatten<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

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

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

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

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

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

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

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

impl<T, U> Debug for SendAll<T, U> where
    T: Debug,
    U: Stream + Debug,
    <U as Stream>::Item: Debug, 

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

impl<S> Debug for Concat2<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

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

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

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

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

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

impl<S> Debug for Buffered<S> where
    S: Stream + Debug,
    <S as Stream>::Item: IntoFuture,
    <<S as Stream>::Item as IntoFuture>::Future: Debug,
    <<S as Stream>::Item as IntoFuture>::Item: Debug,
    <<S as Stream>::Item as IntoFuture>::Error: Debug, 

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

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

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

impl Debug for Canceled

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

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

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

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

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

impl<S> Debug for Collect<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

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

impl Debug for UnparkEvent

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

impl<S, P, R> Debug for SkipWhile<S, P, R> where
    P: Debug,
    R: Debug + IntoFuture,
    S: Debug + Stream,
    <R as IntoFuture>::Future: Debug,
    <S as Stream>::Item: Debug, 

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

impl<T> Debug for FuturesOrdered<T> where
    T: Debug + Future, 

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

impl Debug for InvalidStatusCode

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 PathAndQuery

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

impl Debug for InvalidHeaderName

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

impl Debug for Builder

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

impl Debug for InvalidMethod

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

impl Debug for Parts

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

impl Debug for Uri

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

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

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

impl Debug for InvalidHeaderValueBytes

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

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

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

impl Debug for Builder

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

impl Debug for Scheme

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

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

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

impl Debug for InvalidUri

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

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

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

impl Debug for Extensions

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 StatusCode

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

impl Debug for Authority

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

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

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

impl Debug for InvalidUriBytes

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

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

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

impl Debug for Builder

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

impl Debug for Version

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

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

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

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

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

impl Debug for Parts

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

impl Debug for HeaderName

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

impl Debug for HeaderValue

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

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

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

impl Debug for InvalidUriParts

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

impl Debug for Parts

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

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

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

impl Debug for InvalidHeaderValue

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

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

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

impl Debug for ToStrError

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

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

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

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

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

impl Debug for Error

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

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

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

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

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

impl Debug for InvalidHeaderNameBytes

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

impl Debug for Bytes

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BytesMut

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<B> Debug for Writer<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Take<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for Reader<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LittleEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigEndian

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendRequest<B>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sender

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Payload + 'static,
    T: AsyncRead + AsyncWrite + Debug + Send + 'static, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for Http<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, S> Debug for Connection<I, S, Exec> where
    S: Service, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GaiFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Destination

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Chunk

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, S> Debug for Server<I, S, Exec> where
    I: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F, E> Debug for Connecting<I, F, E> where
    E: Debug,
    F: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HttpInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddrIncoming

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddrStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for Parts<T, S> where
    S: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Parts<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, S, E> Debug for Serve<I, S, E> where
    E: Debug,
    I: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Parts<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TokioThreadpoolGaiResolver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidNameError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Connected

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for Builder<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Upgraded

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TokioThreadpoolGaiFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GaiAddrs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OnUpgrade

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for GaiResolver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Name

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CpuPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for CpuFuture<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Debug + IntoBuf,
    T: AsyncRead + AsyncWrite + Debug,
    <B as IntoBuf>::Buf: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendResponse<B> where
    B: Debug + IntoBuf,
    <B as IntoBuf>::Buf: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendStream<B> where
    B: Debug + IntoBuf,
    <B as IntoBuf>::Buf: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Connection<T, B> where
    B: Debug + IntoBuf,
    T: Debug,
    <B as IntoBuf>::Buf: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StreamId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PushPromises

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for SendRequest<B> where
    B: IntoBuf, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for RecvStream

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PushPromise

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B> where
    B: Debug + IntoBuf,
    T: AsyncRead + AsyncWrite + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T, B> Debug for Handshake<T, B> where
    B: Debug + IntoBuf,
    T: AsyncRead + AsyncWrite + Debug,
    <B as IntoBuf>::Buf: Debug,
    <B as IntoBuf>::Buf: IntoBuf, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Reason

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for ReadySendRequest<B> where
    B: Debug + IntoBuf, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PushedResponseFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReleaseCapacity

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for Read<R, T> where
    R: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Lines<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for WriteHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, W> Debug for Copy<R, W> where
    R: Debug,
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AllowStdIo<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, T> Debug for ReadExact<A, T> where
    A: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ReadUntil<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Flush<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ReadToEnd<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, T> Debug for WriteAll<A, T> where
    A: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Window<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ReadHalf<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Shutdown<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Metadata<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for RecordBuilder<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseLevelError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for MetadataBuilder<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetLoggerError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LevelFilter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Record<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Drain<'a, T> where
    T: 'a, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for String<T> where
    T: AsRef<[u8]>, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for IndexSet<T, S> where
    S: BuildHasher,
    T: Debug + Hash + Eq, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<K, V, S> Debug for IndexMap<K, V, S> where
    K: Debug + Hash + Eq,
    S: BuildHasher,
    V: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Header<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InvalidChunkSize

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'headers, 'buf> Debug for Response<'headers, 'buf> where
    'buf: 'headers, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'headers, 'buf> Debug for Request<'headers, 'buf> where
    'buf: 'headers, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Status<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UdpBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpBuilder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for TmFmt<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OutOfRangeError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Duration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SteadyTime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Tm

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Timespec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Runtime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Spawn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TaskExecutor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Runtime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PollOpt

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetReadiness

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnixReady

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for UdpSocket

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Registration

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Events

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Poll

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Token

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Iter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Ready

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for EventedFd<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LazyCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AtomicLazyCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RunError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<P> Debug for CurrentThread<P> where
    P: Park, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, P> Debug for Entered<'a, P> where
    P: Park, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for TaskExecutor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BlockError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RunTimeoutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TurnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Turn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SpawnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkThread

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Enter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkThread

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EnterError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultExecutor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ShardedLock<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'env> Debug for Scope<'env>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockReadGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitGroup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockWriteGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Unparker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope, T> Debug for ScopedJoinHandle<'scope, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CachePadded<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AtomicCell<T> where
    T: Copy + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'scope, 'env> Debug for ScopedThreadBuilder<'scope, 'env> where
    'env: 'scope, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Backoff

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Registration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Background

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SetFallbackError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Turn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Reactor

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for PollEvented<E> where
    E: Debug + Evented, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OnceState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitTimeoutResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Condvar

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Once

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for Mutex<R, T> where
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, T> Debug for RwLock<R, T> where
    R: RawRwLock,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, G, T> Debug for ReentrantMutex<R, G, T> where
    G: GetThreadId,
    R: RawMutex,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Always

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, F, S> Debug for ScopeGuard<T, F, S> where
    F: FnMut(&mut T),
    S: Strategy + Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<O, T> Debug for OwningRefMut<O, T> where
    O: Debug,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<O, T> Debug for OwningRef<O, T> where
    O: Debug,
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for dyn Erased + 'static

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FilterOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RequeueOp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkToken

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Standard

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gamma

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Triangular

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Hc128Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IndexVec

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Cauchy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for UniformFloat<X> where
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnitCircle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WeightedError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Poisson

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for UniformInt<X> where
    X: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UniformDuration

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Isaac64Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SmallRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, D, R, T> Debug for DistIter<'a, D, R, T> where
    D: 'a + Debug,
    R: 'a + Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Open01

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for WeightedChoice<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for ReadRng<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Bernoulli

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LogNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XorShiftRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for WeightedIndex<X> where
    X: SampleUniform + PartialOrd<X> + Debug,
    <X as SampleUniform>::Sampler: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, S, T> Debug for SliceChooseIter<'a, S, T> where
    S: 'a + Debug + ?Sized,
    T: 'a + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pareto

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Normal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EntropyRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Alphanumeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dirichlet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsaacRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaChaRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IndexVecIntoIter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StandardNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpenClosed01

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for IndexVecIter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for UnitSphereSurface

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Beta

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FisherF

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EntropyRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChiSquared

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Weibull

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StudentT

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Weighted<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StdRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StdRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OsRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where
    R: Debug + BlockRngCore + SeedableRng,
    Rsdr: Debug + RngCore, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Binomial

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StepRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<X> Debug for Uniform<X> where
    X: SampleUniform + Debug,
    <X as SampleUniform>::Sampler: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for JitterRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimerError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BlockRng64<R> where
    R: BlockRngCore + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BlockRng<R> where
    R: BlockRngCore + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OsRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Isaac64Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsaacRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Isaac64Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsaacCore

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaChaRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaChaCore

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Hc128Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Hc128Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Lcg64Xsh32

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Mcg128Xsl64

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XorShiftRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Void

fn fmt(&self, &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Sender

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Worker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultUnpark

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for SpawnHandle<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParkError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ThreadPool

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WorkerId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BlockingError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultPark

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ArcCell<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for WaitGroup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SegQueue<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TreiberStack<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for MsQueue<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ShardedLock<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockReadGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for ShardedLockWriteGuard<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'g, T, P> Debug for CompareAndSetError<'g, T, P> where
    P: Pointer<T> + Debug,
    T: 'g, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LocalHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Guard

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Atomic<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Collector

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'g, T> Debug for Shared<'g, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Owned<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for ArrayString<A> where
    A: Array<Item = u8>, 

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<T> Debug for Steal<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Pop<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Worker<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Stealer<T>

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 RecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReadyTimeoutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for SelectedOperation<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TrySelectError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryReadyError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendTimeoutError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SelectTimeoutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Iter<'a, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RecvTimeoutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Select<'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 TrySendError<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for IntoIter<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TryRecvError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for TryIter<'a, T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Error<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Interval

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Clock

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Turn

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Delay

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Expired<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Throttle<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for DelayQueue<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, N> Debug for Timer<T, N> where
    N: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Key

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ThrottleError<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Timeout<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Incoming

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ConnectFuture

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Taker

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Giver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SharedGiver

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Closed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TryLock<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Locked<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for MaybeHttpsStream<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for HttpsConnecting<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TlsStream<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for HandshakeError<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Protocol

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for MidHandshakeTlsStream<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for TlsStream<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Ssl

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OpensslStringRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslVerifyMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rsa<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DigestBytes

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorStack

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpensslString

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pkcs7Flags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for CMSOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OcspRevokedStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OcspResponseStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for X509CheckFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorCode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Nid

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SrtpProfileId

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslSessionCacheMode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for SslStream<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for SslAlert

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AlpnError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeyIvPair

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigNumRef

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OcspFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslContext

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ShutdownState

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Id

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OcspCertStatus

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SniError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BigNum

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ShutdownResult

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for HandshakeError<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Padding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Dsa<T>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslOptions

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SslRef

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for X509VerifyResult

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for MidHandshakeSslStream<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I128Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U128Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IgnoredAny

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Category

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Number

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for CompactFormatter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Map<String, Value>

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl<S> Debug for HostAndPort<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ParseOptions<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Origin

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Host<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PathSegmentsMut<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SocketAddrs

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Position

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SyntaxViolation

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for UrlQuery<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OpaqueOrigin

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Errors

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'text> Debug for InitialInfo<'text>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParagraphInfo

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BidiClass

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Level

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'text> Debug for BidiInfo<'text>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsNormalized

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PercentDecode<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for PATH_SEGMENT_ENCODE_SET

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for QUERY_ENCODE_SET

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for USERINFO_ENCODE_SET

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SIMPLE_ENCODE_SET

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DEFAULT_ENCODE_SET

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for PercentEncode<'a, E> where
    E: EncodeSet + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OwnedAttribute

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for OwnedName

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for XmlEvent<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParserConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XmlEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EmitterError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Namespace

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TextPosition

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NamespaceStack

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for XmlVersion

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Attribute<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EmitterConfig

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Name<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ProxyAuthorization

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for QualityItem<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RetryAfter

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentCoding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for HttpDate

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentType

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptEncoding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentEncoding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Allow

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AuthScheme

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Token68

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Accept

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ContentLength

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Host

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Quality

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LineWrap

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CharacterSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodeError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LineEnding

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DisplayError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveDate

The Debug output of the naive date d is same to d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

Example

use chrono::NaiveDate;

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LocalResult<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Utc

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Fixed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Parsed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SecondsFormat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveTime

The Debug output of the naive time t is same to t.format("%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn't matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveTime;

assert_eq!(format!("{:?}", NaiveTime::from_hms(23, 56, 4)),              "23:56:04");
assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(23, 56, 4, 12)),    "23:56:04.012");
assert_eq!(format!("{:?}", NaiveTime::from_hms_micro(23, 56, 4, 1234)),  "23:56:04.001234");
assert_eq!(format!("{:?}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");

Leap seconds may also be used.

assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Weekday

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for DelayedFormat<I> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InternalNumeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseWeekdayError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for NaiveDateTime

The Debug output of the naive date and time dt is same to dt.format("%Y-%m-%dT%H:%M:%S%.f").

The string printed can be readily parsed via the parse method on str.

It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn't matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)

Example

use chrono::NaiveDate;

let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");

Leap seconds may also be used.

let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Local

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Tz> Debug for Date<Tz> where
    Tz: TimeZone, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for InternalFixed

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Numeric

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IsoWeek

The Debug output of the ISO week w is same to d.format("%G-W%V") where d is any NaiveDate value in that week.

Example

use chrono::{NaiveDate, Datelike};

assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5).iso_week()), "2015-W36");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  3).iso_week()), "0000-W01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31).iso_week()), "9999-W52");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd(    0,  1,  2).iso_week()),  "-0001-W52");
assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31).iso_week()), "+10000-W52");

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FixedOffset

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Pad

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<Tz> Debug for DateTime<Tz> where
    Tz: TimeZone, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for StrftimeItems<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Item<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ParseFloatError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FloatErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Name<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Params<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Mime

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FromStrError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S> Debug for UniCase<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Ascii<S> where
    S: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Loading content...

Implementors

impl Debug for CallStatus

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for CallbackEvent

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Direction

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for MsgStatus

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for RecordingStatus

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for TwilioErr

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Alignment

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ExecuteErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for twilio_async::io::ErrorKind

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SeekFrom

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for twilio_async::twiml::Method

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for twilio_async::twiml::Record

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Voice

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TwimlErr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BorrowError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for BorrowMutError

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for twilio_async::fmt::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for twilio_async::io::Empty

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for twilio_async::io::Error

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Initializer

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for twilio_async::io::Repeat

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Sink

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Stderr

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Stdin

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Stdout

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Authorization

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Body

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CallResp

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ConferenceResp

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Credentials

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EncryptionDetails

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ListAllMsgs

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ListConferencesResp

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for ListRecordingResp

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for MediaItem

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for MediaResp

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for twilio_async::Method

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsgResp

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for RecordingResp

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Twilio

fn fmt(&self, f: &mut Formatter) -> Result

impl Debug for Url

Debug the serialization of this URL.

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl Debug for Hangup

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_> Debug for Arguments<'_>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for Ref<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'_, T> Debug for RefMut<'_, T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ByteSerialize<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Parse<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for ParseIntoOwned<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for StderrLock<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for StdinLock<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for StdoutLock<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Call<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for Conference<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for GetMessage<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for twilio_async::Msg<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for Recording<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for SendMsg<'a>

fn fmt(&self, f: &mut Formatter) -> Result

impl<'a> Debug for Dial<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Gather<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for twilio_async::twiml::Msg<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Play<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Redirect<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for twilio_async::twiml::Response<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Say<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for twilio_async::future::Flatten<A> where
    A: Future + Debug,
    <A as Future>::Item: IntoFuture,
    <<A as IntoFuture>::Item as IntoFuture>::Future: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A> Debug for twilio_async::future::Fuse<A> where
    A: Future + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SelectAll<A> where
    A: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SelectOk<A> where
    A: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Either<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Join<A, B> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for twilio_async::future::Select<A, B> where
    A: Future + Debug,
    B: Debug + Future<Item = <A as Future>::Item, Error = <A as Future>::Error>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Select2<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for SelectNext<A, B> where
    A: Future + Debug,
    B: Debug + Future<Item = <A as Future>::Item, Error = <A as Future>::Error>, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, C> Debug for Join3<A, B, C> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A, B, C, D> Debug for Join4<A, B, C, D> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    D: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug,
    <D as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A, B, C, D, E> Debug for Join5<A, B, C, D, E> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    D: Future<Error = <A as Future>::Error> + Debug,
    E: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug,
    <D as Future>::Item: Debug,
    <E as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for twilio_async::future::AndThen<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for twilio_async::future::OrElse<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for twilio_async::future::Then<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, E> Debug for twilio_async::future::FromErr<A, E> where
    A: Debug + Future,
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for twilio_async::future::Inspect<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for LoopFn<A, F> where
    A: Debug + IntoFuture,
    F: Debug,
    <A as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for twilio_async::future::Map<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for twilio_async::future::MapErr<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for twilio_async::io::Lines<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<B> Debug for twilio_async::io::Split<B> where
    B: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<C, B> Debug for Client<C, B>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SharedError<E> where
    E: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for twilio_async::future::CatchUnwind<F> where
    F: Debug + Future, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for ExecuteError<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for FlattenStream<F> where
    F: Future + Debug,
    <F as Future>::Item: Stream,
    <F as Future>::Item: Debug,
    <<F as Future>::Item as Stream>::Error == <F as Future>::Error, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<F> Debug for IntoStream<F> where
    F: Future + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for twilio_async::future::PollFn<F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for twilio_async::future::Shared<F> where
    F: Future + Debug,
    <F as Future>::Item: Debug,
    <F as Future>::Error: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<F, R> Debug for Lazy<F, R> where
    F: Debug,
    R: IntoFuture + Debug,
    <R as IntoFuture>::Future: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for JoinAll<I> where
    I: IntoIterator,
    <I as IntoIterator>::Item: IntoFuture,
    <<I as IntoIterator>::Item as IntoFuture>::Future: Debug,
    <<I as IntoIterator>::Item as IntoFuture>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<R> Debug for twilio_async::io::Bytes<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<R> Debug for HttpConnector<R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Cell<T> where
    T: Copy + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnsafeCell<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Serializer<T> where
    T: Target + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SharedItem<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Cursor<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for twilio_async::io::Take<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for HttpsConnector<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Rc<T> where
    T: Debug + ?Sized, 

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<T> Debug for twilio_async::Request<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for twilio_async::future::Empty<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for FutureResult<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for Loop<T, S> where
    S: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, U> Debug for twilio_async::io::Chain<T, U> where
    T: Debug,
    U: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Write + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<W> Debug for IntoInnerError<W> where
    W: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<W> Debug for LineWriter<W> where
    W: Write + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

Loading content...