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, }));

Implementations on Foreign Types

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

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

impl Debug for Select

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

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

impl Debug for ChildStderr

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

impl Debug for ThreadId

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

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

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

impl Debug for StripPrefixError

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

impl Debug for BarrierWaitResult

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 ExitCode

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

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

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 FileType

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

impl<T> Debug for TrySendError<T>

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

impl Debug for JoinPathsError

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 SocketAddr

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

impl<T> Debug for SendError<T>

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

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

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

impl<T> Debug for JoinHandle<T>

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

impl Debug for Metadata

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

impl Debug for Ipv6Addr

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

impl Debug for Child

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 ExitStatus

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

impl Debug for SocketAddrV4

fn fmt(&self, fmt: &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, K> Debug for Drain<'a, K> where     K: Debug,

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

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

impl Debug for VarsOs

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

impl Debug for AddrParseError

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

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

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

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

impl Debug for DirEntry

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

impl Debug for Permissions

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

impl Debug for Vars

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

impl Debug for CString

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

impl Debug for ChildStdout

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 FromBytesWithNulError

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

impl<T> Debug for PoisonError<T>

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

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

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

impl Debug for PathBuf

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

impl Debug for VarError

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

impl Debug for SystemTime

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

impl Debug for SystemTimeError

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

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

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

impl Debug for Builder

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

impl<T> Debug for Key<T>

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

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

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

impl Debug for UnixStream

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

impl Debug for RecvTimeoutError

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

impl Debug for CStr

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

impl Debug for Args

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 TcpStream

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

impl Debug for Ipv6MulticastScope

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> Debug for Component<'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 NulError

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

impl Debug for OnceState

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

impl Debug for Ipv4Addr

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

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

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

impl Debug for DefaultHasher

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

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

impl Debug for IntoStringError

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

impl Debug for ChildStdin

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

impl Debug for RandomState

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

impl Debug for IpAddr

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

impl Debug for ReadDir

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

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

impl Debug for TcpListener

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

impl Debug for OsStr

fn fmt(&self, formatter: &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 Thread

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

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

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 c_void

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 UnixDatagram

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

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

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

impl Debug for TryRecvError

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

fn fmt(&self, fmt: &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<'a, K, V> Debug for Keys<'a, K, V> where     K: Debug,

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

impl Debug for Condvar

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

impl Debug for File

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

impl Debug for WaitTimeoutResult

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

impl Debug for UdpSocket

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

impl Debug for Once

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

impl<T> Debug for TryLockError<T>

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

impl Debug for SocketAddr

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

impl Debug for AccessError

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

impl Debug for Path

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

impl<T> Debug for Receiver<T>

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

impl Debug for Barrier

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<K> Debug for IntoIter<K> 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 ArgsOs

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 Key<T>

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

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

impl Debug for OsString

fn fmt(&self, formatter: &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 m16x16

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

impl Debug for __m128i

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

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

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

impl Debug for NonZeroU128

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 Pinned

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

impl Debug for ParseBoolError

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

impl Debug for m16x4

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

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

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

impl Debug for AtomicIsize

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

impl Debug for AllocErr

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

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

impl Debug for AtomicI16

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

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

impl Debug for __m256d

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 __m128

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, 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 m8x4

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

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

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

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

impl Debug for m32x2

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

impl Debug for u8x8

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

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

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

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

impl Debug for CollectionAllocErr

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

impl Debug for i128

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

impl Debug for u32x2

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

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

impl Debug for i64

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

impl Debug for RangeFull

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

impl Debug for f32x8

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

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

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

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

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

impl Debug for f32

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

impl Debug for CannotReallocInPlace

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

impl Debug for i8x8

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

impl Debug for i64x2

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

impl Debug for i16x2

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

impl Debug for AtomicI32

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

impl Debug for NonZeroU16

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 u32x4

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

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

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

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

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

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

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

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

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

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

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

impl Debug for u128

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

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

impl Debug for i16x4

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

impl Debug for NonZeroU32

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

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

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

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

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

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

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

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

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

impl Debug for AtomicBool

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

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

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

impl Debug for usize

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

impl Debug for i8x2

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

impl<H> Debug for BuildHasherDefault<H>

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

impl Debug for EscapeDefault

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

impl Debug for !

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

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

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 u64x8

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

impl Debug for NonZeroU8

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

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

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

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

impl Debug for Utf8Error

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

impl Debug for Duration

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

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

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

impl Debug for SearchStep

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

impl Debug for u32

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 RangeToInclusive<Idx> where     Idx: Debug,

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

impl Debug for Alignment

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

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 NonZeroUsize

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

impl Debug for ParseCharError

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

impl Debug for f32x2

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

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

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

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

impl Debug for bool

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

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

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

impl Debug for u16x8

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

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

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

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

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

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

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

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

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

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

impl Debug for i64x8

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

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

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

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

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

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

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

impl Debug for i64x4

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

impl Debug for i8x4

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

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

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

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

impl Debug for ()

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

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

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

impl Debug for __m128d

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

impl Debug for Utf8Lossy

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

impl Debug for i16x16

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

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

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

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

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

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

impl Debug for u32x8

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

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

impl Debug for Layout

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

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

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

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

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

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

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

impl Debug for __m64

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

impl Debug for f32x4

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

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

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

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

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

impl Debug for __m256i

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

impl Debug for u16

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

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

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

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

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

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

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

impl Debug for u64x2

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

impl Debug for i32x4

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

impl Debug for u8x4

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

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

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

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

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

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

impl Debug for AtomicU16

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

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

impl Debug for AtomicUsize

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

impl Debug for u8x2

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<'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 m16x2

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

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

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

impl<'a> Debug for EncodeUtf16<'a>

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

impl Debug for m64x4

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

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

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

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

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

impl Debug for TryFromIntError

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

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

impl Debug for f64

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

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

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

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

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

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

impl Debug for Any + 'static

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

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

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

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

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

impl Debug for u8x32

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

impl Debug for AtomicU8

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for ToLowercase

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

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

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

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

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

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

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

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

impl<'a, A> Debug for Iter<'a, A> where     A: 'a + 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 Debug for i8x64

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<I> Debug for Cycle<I> where     I: 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 Debug for u64x4

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> Debug for extern "C" fn(A, B, C, ...) -> 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<T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T4, T5, T6, T7, T8, T9, T10, T11) where     T10: Debug,     T11: Debug + ?Sized,     T4: Debug,     T5: Debug,     T6: Debug,     T7: Debug,     T8: Debug,     T9: Debug,

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

impl Debug for i32

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

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

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

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

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

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, 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<T10, T11> Debug for (T10, T11) where     T10: Debug,     T11: Debug + ?Sized,

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

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

impl Debug for f64x4

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

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

impl Debug for EscapeDebug

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

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

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

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

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

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

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

impl Debug for Any + 'static + Send + Sync

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

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

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

impl Debug for i16

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

impl Debug for SipHasher

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 AtomicPtr<T>

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

impl Debug for f64x8

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

impl Debug for CharTryFromError

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

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 FpCategory

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

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

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

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

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

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

impl Debug for i32x8

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

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

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

impl Debug for u64

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

impl Debug for u16x32

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

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

impl Debug for u32x16

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

impl Debug for AtomicI8

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

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

impl Debug for m1x32

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<'a, T, P> Debug for Split<'a, T, P> where     P: FnMut(&T) -> bool,     T: 'a + Debug,

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

impl Debug for u8x64

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

impl Debug for m1x8

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

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

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

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

impl Debug for u8x16

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

impl Debug for i32x16

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

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

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

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

impl Debug for __m256

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

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

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

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

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

impl Debug for f64x2

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

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

impl Debug for NonZeroU64

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

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 i8

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

impl Debug for EscapeDefault

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

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

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

impl Debug for m8x32

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

impl Debug for AtomicU64

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

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

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

impl Debug for m32x4

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> 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 Empty<T>

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

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

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

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

impl Debug for TypeId

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

impl Debug for u16x4

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

impl Debug for m32x8

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

impl Debug for m8x16

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

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

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

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

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

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

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

impl Debug for AtomicU32

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

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

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

impl Debug for m8x2

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 isize

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

impl Debug for ParseFloatError

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

impl Debug for InvalidSequence

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

impl Debug for UnicodeVersion

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

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

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

impl Debug for DecodeUtf16Error

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 m1x16

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<'a, T, P> Debug for SplitMut<'a, T, P> where     P: FnMut(&T) -> bool,     T: 'a + Debug,

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

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<'a, T> Debug for Intersection<'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<'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 Debug for FromUtf8Error

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, 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 Debug for ParseError

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

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

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

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

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

impl<K, V> Debug for IntoIter<K, V> where     K: Debug,     V: 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<T> Debug for BTreeSet<T> where     T: Debug,

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

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

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

impl<'a, T> Debug for PeekMut<'a, T> where     T: Ord + 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 IterMut<'a, K, V> where     K: 'a + Debug,     V: '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 SymmetricDifference<'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<'a, T> Debug for Difference<'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<T> Debug for Weak<T> where     T: Debug + ?Sized,

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

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

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

impl<'a, T> Debug for IterMut<'a, T> where     T: '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 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<T> Debug for IntoIter<T> where     T: 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<'a, K, V> Debug for ValuesMut<'a, K, V> where     K: 'a + Debug,     V: 'a + Debug,

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

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

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

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

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

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> Debug for Drain<'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<'a, T> Debug for IterMut<'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<'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 Range<'a, K, V> where     K: 'a + Debug,     V: '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 RangeMut<'a, K, V> where     K: 'a + Debug,     V: 'a + Debug,

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

impl Debug for _Unwind_Reason_Code

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

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

impl Debug for UnparkEvent

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

fn fmt(&self, f: &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<I, E> Debug for SpawnHandle<I, E>

fn fmt(&self, f: &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<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<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 UnboundedReceiver<T> where     T: 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, 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<S1, S2> Debug for Select<S1, S2> where     S1: Debug,     S2: 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<T> Debug for UnboundedSender<T> where     T: Debug,

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

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

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

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

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

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, 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<T, E> Debug for Empty<T, E> where     E: Debug,     T: 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<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<S> Debug for Wait<S> where     S: 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 Debug for Task

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<I> Debug for Iter<I> where     I: 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<S> Debug for Buffer<S> where     S: Sink + Debug,     <S as Sink>::SinkItem: Debug,

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

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<S> Debug for Execute<S> where     S: Stream,

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

impl<T> Debug for ReuniteError<T>

fn fmt(&self, fmt: &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<S> Debug for Take<S> where     S: 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, 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, E> Debug for Receiver<T, E> where     E: Debug,     T: 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<S> Debug for Send<S> where     S: Sink + Debug,     <S as Sink>::SinkItem: 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<S> Debug for StreamFuture<S> where     S: 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<S> Debug for Fuse<S> where     S: 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<T> Debug for Receiver<T> where     T: Debug,

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

impl Debug for AtomicTask

fn fmt(&self, fmt: &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<T> Debug for UnboundedSender<T> where     T: 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<I, E> Debug for IterOk<I, E> where     E: Debug,     I: 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<S, F> Debug for Inspect<S, F> where     F: Debug,     S: Debug + Stream,

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

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

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

impl<T> Debug for SendError<T>

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

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

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

impl<T> Debug for BiLock<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<S> Debug for SplitSink<S> where     S: 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> Debug for TrySendError<T>

fn fmt(&self, fmt: &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<S> Debug for Collect<S> where     S: Debug + Stream,     <S as Stream>::Item: 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<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, F> Debug for FilterMap<S, F> where     F: Debug,     S: 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<T> Debug for FuturesOrdered<T> where     T: Debug + Future,

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

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<F> Debug for Execute<F> where     F: Future + 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<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 Filter<S, F> where     F: Debug,     S: 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<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 CatchUnwind<S> where     S: Debug + Stream,

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<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, E> Debug for Repeat<T, E> where     E: Debug,     T: Debug + Clone,

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 Concat2<S> where     S: Debug + Stream,     <S as Stream>::Item: Debug,

fn fmt(&self, fmt: &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<S> Debug for Concat<S> where     S: Debug + Stream,     <S as Stream>::Item: Debug,

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

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

impl Debug for Run

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

impl Debug for Canceled

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

impl Debug for Builder

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

impl Debug for AddrIncoming

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

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 StatusCode

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

impl Debug for UseDefaultConnector

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

impl Debug for UriError

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

impl<I, S> Debug for Serve<I, S> where     I: Debug,     S: Debug,

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

impl Debug for Error

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

impl<C, B> Debug for Config<C, B>

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

impl<B> Debug for Http<B>

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

impl Debug for FutureResponse

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

impl Debug for Chunk

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

impl Debug for ResponseFuture

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

impl Debug for Response<Body>

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

impl Debug for Body

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

impl<T, B> Debug for Connection<T, B> where     B: Stream<Error = Error> + 'static,     T: AsyncRead + AsyncWrite + Debug,     <B as Stream>::Item: AsRef<[u8]>,

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 HttpVersion

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

impl<B> Debug for SendRequest<B>

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

impl<S, B> Debug for Server<S, B> where     B: Stream<Error = Error>,     S: Debug,     <B as Stream>::Item: AsRef<[u8]>,

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

impl<I, S> Debug for Connection<I, S> where     S: HyperService,     <S as HyperService>::ResponseBody: Stream,     <<S as HyperService>::ResponseBody as Stream>::Item: AsRef<[u8]>,     <<S as HyperService>::ResponseBody as Stream>::Error == Error,

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

impl Debug for CharacterSet

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

impl Debug for Config

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

impl Debug for DecodeError

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

impl Debug for LineEnding

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

impl Debug for LineWrap

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

impl Debug for DisplayError

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 Reader<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 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<T, U> Debug for Chain<T, U> where     T: Debug,     U: Debug,

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

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

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 CpuPool

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

impl Debug for Builder

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

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

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

impl Debug for InvalidChunkSize

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 Error

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

impl Debug for LevelFilter

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

impl Debug for ParseLevelError

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

impl<'a> Debug for Record<'a>

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

impl<'a> Debug for Metadata<'a>

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

impl Debug for SetLoggerError

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

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

impl Debug for TcpBuilder

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

impl Debug for UdpBuilder

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 USERINFO_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 Debug for QUERY_ENCODE_SET

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

impl<'a> Debug for PercentDecode<'a>

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 PATH_SEGMENT_ENCODE_SET

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

impl<T> Debug for Waiting<T>

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 Canceled

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 Timespec

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

impl Debug for Duration

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

impl Debug for OutOfRangeError

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

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

impl Debug for TcpListener

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

impl Debug for CoreId

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

impl Debug for Timeout

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 Remote

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

impl Debug for UdpSocket

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

impl Debug for TcpStream

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

impl Debug for Handle

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

impl Debug for Registration

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

impl Debug for UdpSocket

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

impl Debug for Token

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

impl Debug for UnixReady

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

impl Debug for SetReadiness

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

impl Debug for PollOpt

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

impl Debug for Events

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

impl Debug for Ready

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

impl Debug for TcpListener

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

impl Debug for TcpStream

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

impl Debug for Event

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

impl<'a> Debug for EventedFd<'a>

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

impl Debug for Poll

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

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

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<T> Debug for LazyCell<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, 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 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, f: &mut Formatter) -> Result<(), Error>

impl Debug for Spawn

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

impl Debug for TurnError

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 RunTimeoutError

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

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

impl Debug for Builder

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

impl Debug for TaskExecutor

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

impl Debug for Turn

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

impl Debug for Runtime

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 Shutdown

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

impl Debug for RunError

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 TaskExecutor

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

impl Debug for Handle

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

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

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<T, U> Debug for FramedParts<T, U> where     T: Debug,     U: 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 ReadUntil<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<T, U> Debug for FramedWrite<T, U> where     T: Debug,     U: 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<A> Debug for Flush<A> where     A: Debug,

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

impl<T, D> Debug for FramedRead<T, D> where     D: Debug,     T: Debug,

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

impl<T, U> Debug for Framed<T, U> where     T: Debug,     U: 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 Shutdown<A> where     A: 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<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 WriteHalf<T> where     T: Debug,

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

impl Debug for SpawnError

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

impl Debug for DefaultExecutor

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 ParkError

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

impl Debug for Enter

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

impl Debug for UnparkThread

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

impl Debug for File

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

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

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

impl Debug for Stderr

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

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

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

impl Debug for Stdout

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

impl Debug for Stdin

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

impl Debug for OpenOptions

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

impl Debug for DefaultUnpark

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

impl Debug for ThreadPool

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

impl Debug for ParkError

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

impl Debug for Builder

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

impl Debug for Worker

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

impl Debug for BlockingError

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

impl Debug for Shutdown

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

impl Debug for Sender

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

impl Debug for DefaultPark

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 Deque<T>

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<'g, T> Debug for Shared<'g, T>

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

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

impl Debug for Handle

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

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

impl<T> Debug for CapacityError<T>

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

impl<A> Debug for ArrayVec<A> where     A: Array,     <A as Array>::Item: Debug,

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

impl<A> Debug for ArrayString<A> where     A: Array<Item = u8>,

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

impl<'a, T> Debug for ScopedJoinHandle<'a, T>

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

impl<'a> Debug for Scope<'a>

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, 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 Debug for Always

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 Gamma

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

impl Debug for LogNormal

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

impl Debug for ThreadRng

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

impl Debug for ReseedWithDefault

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

impl Debug for StudentT

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

impl Debug for ChaChaRng

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

impl Debug for StandardNormal

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

impl<Sup> Debug for RandSample<Sup> where     Sup: Debug,

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

impl Debug for Isaac64Rng

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

impl Debug for JitterRng

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

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

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

impl Debug for TimerError

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

impl Debug for IsaacRng

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

impl<R, Rsdr> Debug for ReseedingRng<R, Rsdr> where     R: Debug,     Rsdr: Debug,

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

impl Debug for Exp1

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

impl Debug for StdRng

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

impl Debug for ChiSquared

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 FisherF

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

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

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

impl Debug for Normal

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

impl<'a, R> Debug for AsciiGenerator<'a, R> where     R: 'a + Debug,

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

impl Debug for XorShiftRng

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

impl Debug for Exp

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

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

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

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

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

impl Debug for OsRng

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

impl Debug for Handle

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

impl Debug for SetFallbackError

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

impl Debug for Reactor

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 Registration

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

impl Debug for Turn

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

impl Debug for Background

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

impl Debug for Interval

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

impl Debug for Handle

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

impl Debug for Delay

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

impl Debug for Error

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

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

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

impl Debug for Clock

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

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

impl Debug for Turn

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 UdpSocket

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

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

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

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

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

impl<C> Debug for UdpFramed<C> where     C: Debug,

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

impl Debug for BytesCodec

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

impl Debug for LinesCodec

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

impl<T, B, E> Debug for MultiplexMessage<T, B, E> where     B: Debug,     E: Debug,     T: Debug,

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

impl<Kind, P> Debug for Connect<Kind, P>

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

impl<T> Debug for Pipeline<T> where     T: Dispatch + Debug,     <T as Dispatch>::In: Debug,     <T as Dispatch>::BodyIn: Debug,     <T as Dispatch>::BodyOut: Debug,     <T as Dispatch>::Error: Debug,     <T as Dispatch>::Stream: Debug,

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

impl<Kind, P> Debug for TcpServer<Kind, P> where     Kind: Debug,     P: Debug,

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

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

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

impl<T> Debug for Multiplex<T> where     T: Dispatch + Debug,     <T as Dispatch>::In: Debug,     <T as Dispatch>::Out: Debug,     <T as Dispatch>::BodyIn: Debug,     <T as Dispatch>::BodyOut: Debug,     <T as Dispatch>::Error: Debug,     <T as Dispatch>::Stream: Debug,

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

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

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

impl<T, B, E> Debug for Frame<T, B, E> where     B: Debug,     E: Debug,     T: Debug,

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

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

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

impl<Kind, P> Debug for TcpClient<Kind, P> where     Kind: Debug,     P: Debug,

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

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

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

impl<R, S, E> Debug for ClientProxy<R, S, E> where     E: Debug,     R: Debug,     S: Debug,

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

impl<T, B> Debug for Message<T, B> where     T: Debug,

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

impl<T, B, E> Debug for Frame<T, B, E> where     B: Debug,     E: Debug,     T: Debug,

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

impl<T, I> Debug for Slab<T, I> where     I: Debug,     T: Debug,

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

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

impl Debug for SetLoggerError

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

impl Debug for LogLocation

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

impl Debug for LogLevelFilter

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

impl Debug for ShutdownLoggerError

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

impl Debug for LogLevel

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

impl Debug for MaxLogLevelFilter

fn fmt(&self, fmt: &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 Debug for Taker

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>

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

impl<T> Debug for HttpsConnecting<T>

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

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

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

impl Debug for Protocol

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 Error

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

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

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

impl Debug for X509VerifyError

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

impl Debug for OpensslStringRef

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

impl Debug for SslRef

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

impl Debug for Dsa

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

impl Debug for DigestBytes

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

impl Debug for Rsa

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

impl Debug for BigNumRef

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

impl Debug for SslContext

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

impl Debug for SslOption

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

impl Debug for OpensslString

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

impl Debug for BigNum

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

impl Debug for Nid

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

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

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 SslStream<S> where     S: Debug,

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

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

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

impl Debug for Error

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

impl Debug for Flag

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

impl Debug for ErrorStack

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

impl Debug for OcspRevokedStatus

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

impl Debug for Ssl

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

impl Debug for OcspCertStatus

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

impl Debug for KeyIvPair

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

impl Debug for SslVerifyMode

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

impl Debug for Padding

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

impl Debug for KeyError

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

impl Debug for OcspResponseStatus

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

impl Debug for RetryError

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

impl Debug for SslMode

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

impl Debug for Flags

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

impl<S> Debug for TlsStream<S> where     S: 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 U32Deserializer<E> where     E: Debug,

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

impl<E> Debug for I32Deserializer<E> where     E: Debug,

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

impl<E> Debug for U64Deserializer<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<'a, E> Debug for CowStrDeserializer<'a, E> where     E: Debug,

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

impl<E> Debug for UsizeDeserializer<E> where     E: Debug,

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

impl<E> Debug for I16Deserializer<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 I64Deserializer<E> where     E: Debug,

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

impl<E> Debug for IsizeDeserializer<E> where     E: Debug,

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

impl<I, E> Debug for SeqDeserializer<I, E> where     E: Debug,     I: 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<A> Debug for SeqAccessDeserializer<A> where     A: 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 U8Deserializer<E> where     E: Debug,

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

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where     I: Iterator + Debug,     <I as Iterator>::Item: Pair,     <<I as Iterator>::Item as Pair>::Second: Debug,

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

impl<'de, E> Debug for BorrowedStrDeserializer<'de, 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 I8Deserializer<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<E> Debug for I128Deserializer<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<'de, E> Debug for BorrowedBytesDeserializer<'de, 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 F32Deserializer<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<'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 Debug for Number

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

impl Debug for Value

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

impl Debug for CompactFormatter

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 Category

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

impl Debug for Error

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

impl Debug for Map<String, Value>

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

impl Debug for Origin

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 ParseError

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

impl Debug for Position

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

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

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

impl Debug for OpaqueOrigin

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

impl Debug for SyntaxViolation

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

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 SocketAddrs

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

impl Debug for Errors

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

impl Debug for BidiClass

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 Level

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

impl Debug for Error

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

impl Debug for ParagraphInfo

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 IsNormalized

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

impl Debug for Error

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

impl Debug for ParserConfig

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 NamespaceStack

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

impl Debug for Namespace

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

impl Debug for OwnedAttribute

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

impl Debug for ErrorKind

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 EmitterConfig

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

impl Debug for EmitterError

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

impl Debug for TextPosition

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

impl Debug for OwnedName

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

impl Debug for XmlVersion

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 XmlEvent

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

Implementors

• impl Debug for twilio_async::io::Error

• impl<B> Debug for twilio_async::io::Split<B> where     B: Debug,

• impl<'a> Debug for StderrLock<'a>

• impl Debug for twilio_async::io::Empty

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

• impl<T> Debug for twilio_async::io::Take<T> where     T: Debug,

• impl<'a> Debug for StdinLock<'a>

• impl Debug for twilio_async::io::ErrorKind

• impl Debug for twilio_async::io::Stdin

• impl Debug for twilio_async::io::Repeat

• impl Debug for SeekFrom

• impl Debug for Initializer

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

• impl Debug for Sink

• impl<B> Debug for twilio_async::io::Lines<B> where     B: Debug,

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

• impl Debug for twilio_async::io::Stderr

• impl<R> Debug for twilio_async::io::Chars<R> where     R: Debug,

• impl<T, U> Debug for twilio_async::io::Chain<T, U> where     T: Debug,     U: Debug,

• impl<R> Debug for twilio_async::io::Bytes<R> where     R: Debug,

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

• impl Debug for twilio_async::io::Stdout

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

• impl Debug for CharsError

• impl<'a> Debug for StdoutLock<'a>

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

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

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

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

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

• impl<'a> Debug for Arguments<'a>

• impl Debug for BorrowError

• impl Debug for twilio_async::fmt::Error

• impl Debug for BorrowMutError

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

• impl<A, F> Debug for twilio_async::future::Map<A, F> where     A: Debug + Future,     F: Debug,

• 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,

• 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,

• impl<A, B> Debug for Either<A, B> where     A: Debug,     B: Debug,

• 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,

• 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,

• 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,

• impl<F> Debug for twilio_async::future::PollFn<F> where     F: Debug,

• impl<T, E> Debug for twilio_async::future::Empty<T, E> where     E: Debug,     T: Debug,

• impl<A, B> Debug for Select2<A, B> where     A: Debug,     B: Debug,

• 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,

• impl<A, F> Debug for twilio_async::future::MapErr<A, F> where     A: Debug + Future,     F: Debug,

• 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,

• 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,

• impl<T, E> Debug for FutureResult<T, E> where     E: Debug,     T: Debug,

• 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,

• 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,

• impl<T> Debug for SharedItem<T> where     T: Debug,

• impl<A> Debug for SelectAll<A> where     A: Debug + Future,

• 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>,

• impl<F> Debug for twilio_async::future::Shared<F> where     F: Future + Debug,     <F as Future>::Item: Debug,     <F as Future>::Error: Debug,

• impl<F> Debug for ExecuteError<F>

• impl<A> Debug for twilio_async::future::Fuse<A> where     A: Future + Debug,

• impl<F> Debug for twilio_async::future::CatchUnwind<F> where     F: Debug + Future,

• impl<A, F> Debug for twilio_async::future::Inspect<A, F> where     A: Debug + Future,     F: Debug,

• impl<F, R> Debug for Lazy<F, R> where     F: Debug,     R: IntoFuture + Debug,     <R as IntoFuture>::Future: Debug,

• impl<A> Debug for SelectOk<A> where     A: Debug + Future,

• impl<E> Debug for SharedError<E> where     E: Debug,

• impl<A, E> Debug for twilio_async::future::FromErr<A, E> where     A: Debug + Future,     E: Debug,

• impl<A, F> Debug for LoopFn<A, F> where     A: Debug + IntoFuture,     F: Debug,     <A as IntoFuture>::Future: Debug,

• 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>,

• impl<F> Debug for IntoStream<F> where     F: Future + Debug,

• impl Debug for ExecuteErrorKind

• impl<T, S> Debug for Loop<T, S> where     S: Debug,     T: Debug,

• impl Debug for Upgrade

• impl Debug for AccessControlAllowMethods

• impl Debug for Pragma

• impl Debug for Vary

• impl Debug for ContentType

• impl Debug for RangeUnit

• impl Debug for AccessControlRequestMethod

• impl Debug for ContentDisposition

• impl Debug for AccessControlAllowHeaders

• impl Debug for ContentLocation

• impl Debug for Prefer

• impl Debug for Referer

• impl Debug for LastEventId

• impl Debug for twilio_async::Method

• impl<B> Debug for twilio_async::Request<B>

• impl Debug for ETag

• impl Debug for HttpConnector

• impl Debug for DispositionType

• impl Debug for AcceptLanguage

• impl Debug for twilio_async::header::Server

• impl Debug for IfUnmodifiedSince

• impl Debug for Te

• impl Debug for From

• impl Debug for CacheControl

• impl<S> Debug for Authorization<S> where     S: Scheme + Debug,

• impl Debug for Preference

• impl Debug for HttpDate

• impl<C, B> Debug for Client<C, B>

• impl Debug for twilio_async::header::Protocol

• impl Debug for ConnectionOption

• impl Debug for ContentRange

• impl Debug for RetryAfter

• impl Debug for ReferrerPolicy

• impl Debug for Warning

• impl Debug for ContentRangeSpec

• impl Debug for twilio_async::header::Connection

• impl Debug for AcceptRanges

• impl Debug for twilio_async::header::Location

• impl Debug for Link

• impl Debug for IfNoneMatch

• impl Debug for CacheDirective

• impl Debug for SetCookie

• impl Debug for Allow

• impl Debug for ContentLength

• impl Debug for AccessControlMaxAge

• impl Debug for PreferenceApplied

• impl<'a> Debug for CookieIter<'a>

• impl Debug for Accept

• impl<T> Debug for QualityItem<T> where     T: Debug,

• impl Debug for AccessControlAllowCredentials

• impl Debug for TransferEncoding

• impl Debug for UserAgent

• impl Debug for ContentLanguage

• impl Debug for RelationType

• impl Debug for IfRange

• impl Debug for twilio_async::header::Host

• impl Debug for AccessControlRequestHeaders

• impl Debug for ByteRangeSpec

• impl Debug for Expires

• impl Debug for StrictTransportSecurity

• impl Debug for ContentEncoding

• impl<'a> Debug for HeaderView<'a>

• impl Debug for AccessControlAllowOrigin

• impl Debug for Charset

• impl Debug for Cookie

• impl Debug for Expect

• impl Debug for twilio_async::header::Origin

• impl Debug for DispositionParam

• impl Debug for IfMatch

• impl Debug for Headers

• impl Debug for LinkValue

• impl Debug for AcceptEncoding

• impl Debug for LastModified

• impl Debug for Date

• impl Debug for Basic

• impl Debug for MediaDesc

• impl Debug for IfModifiedSince

• impl Debug for ProtocolName

• impl Debug for AcceptCharset

• impl Debug for Encoding

• impl<S> Debug for ProxyAuthorization<S> where     S: Scheme + Debug,

• impl Debug for Raw

• impl Debug for AccessControlExposeHeaders

• impl Debug for ExtendedValue

• impl Debug for twilio_async::header::Range

• impl Debug for EntityTag

• impl Debug for Quality

• impl Debug for Bearer

• impl Debug for LanguageTag

• impl Debug for Core

• impl<T> Debug for HttpsConnector<T>

• impl<T> Debug for Serializer<T> where     T: Target + Debug,

• impl Debug for Url

• impl<'a> Debug for ParseIntoOwned<'a>

• impl<'a> Debug for ByteSerialize<'a>

• impl<'a> Debug for Parse<'a>

• impl<'a> Debug for Call<'a>

• impl Debug for CallbackEvent

• impl Debug for CallStatus

• impl Debug for CallResp

• impl Debug for Direction

• impl<'a> Debug for Conference<'a>

• impl Debug for ListConferencesResp

• impl Debug for ConferenceResp

• impl Debug for TwilioErr

• impl<'a> Debug for twilio_async::Msg<'a>

• impl Debug for MsgStatus

• impl Debug for MsgResp

• impl<'a> Debug for SendMsg<'a>

• impl<'a> Debug for GetMessage<'a>

• impl Debug for MediaResp

• impl Debug for MediaItem

• impl Debug for ListAllMsgs

• impl<'a> Debug for Recording<'a>

• impl Debug for ListRecordingResp

• impl Debug for RecordingResp

• impl Debug for EncryptionDetails

• impl Debug for RecordingStatus

• impl<'a> Debug for Dial<'a>

• impl Debug for twilio_async::twiml::dial::Record

• impl<'a> Debug for Gather<'a>

• impl<'a> Debug for twilio_async::twiml::msg::Msg<'a>

• impl<'a> Debug for Play<'a>

• impl<'a> Debug for Redirect<'a>

• impl<'a> Debug for twilio_async::twiml::response::Response<'a>

• impl<'a> Debug for Say<'a>

• impl Debug for Voice

• impl Debug for twilio_async::twiml::Method

• impl Debug for Twilio