Trait artifact_app::dev_prefix::Debug

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

Format trait for the ? character.

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.

Trait Implementations

impl Trait for Debug + 'static + Send

impl Trait for Debug + 'static + Send + Sync

impl Trait for Debug + 'static + Sync

Implementations on Foreign Types

impl Debug for CharacterSet

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

impl Debug for DecodeError

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

impl Debug for Config

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

impl Debug for LineEnding

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

impl Debug for LineWrap

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

impl Debug for ErrorCode

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

impl Debug for CharacterSet

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

impl Debug for JsonEvent

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

impl Debug for FromHexError

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

impl Debug for Json

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

impl Debug for ParserError

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

impl<'l> Debug for StackElement<'l>

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

impl Debug for FromBase64Error

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

impl Debug for DecoderError

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

impl Debug for EncoderError

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

impl Debug for Config

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

impl Debug for Newline

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

impl Debug for ReleaseListBuilder

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

impl Debug for ReleaseAsset

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

impl<'a> Debug for Move<'a>

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

impl Debug for Error

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

impl Debug for UpdateBuilder

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

impl Debug for EncodingKind

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

impl Debug for Download

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

impl Debug for Update

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

impl Debug for Release

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

impl Debug for Status

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

impl Debug for ReleaseList

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

impl Debug for ArchiveKind

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

impl<'a> Debug for Extract<'a>

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

impl Debug for HeaderMode

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

impl Debug for EntryType

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

impl Debug for Utf8Sequence

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

impl Debug for Utf8Range

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

impl Debug for LogLevelFilter

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

impl Debug for LogLocation

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

impl<'a> Debug for LogMetadata<'a>

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

impl Debug for SetLoggerError

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

impl Debug for MaxLogLevelFilter

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

impl<'a> Debug for LogRecord<'a>

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

impl Debug for LogLevel

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

impl Debug for ShutdownLoggerError

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

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

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

impl Debug for FisherF

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

impl Debug for ChiSquared

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

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

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

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

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

impl Debug for StudentT

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

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

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

impl Debug for Exp

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

impl Debug for Isaac64Rng

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

impl Debug for OsRng

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

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

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

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

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

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

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

impl Debug for StandardNormal

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

impl Debug for ThreadRng

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

impl Debug for ReseedWithDefault

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

impl Debug for StdRng

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

impl Debug for Gamma

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

impl Debug for Exp1

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

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

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

impl Debug for LogNormal

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

impl Debug for IsaacRng

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

impl Debug for ChaChaRng

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

impl Debug for Normal

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

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

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

impl Debug for XorShiftRng

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

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

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

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

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

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

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

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

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

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

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

impl Debug for BytesMut

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

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

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

impl Debug for Bytes

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

impl Debug for Error

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

impl Debug for StrSimError

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

impl Debug for Error

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

impl Debug for BidiClass

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

impl<'text> Debug for InitialInfo<'text>

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

impl<'text> Debug for BidiInfo<'text>

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

impl Debug for Level

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

impl Debug for ParagraphInfo

fn fmt(&self, __arg_0: &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<T> Debug for *const T where
    T: ?Sized, 

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

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

impl Debug for TypeId

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

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

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

impl<Ret, A, B, C, D> Debug for unsafe fn(A, B, C, D) -> 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<T> Debug for [T; 29] where
    T: Debug, 

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

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

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

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

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

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

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

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

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<'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<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<'a, T> Debug for &'a mut T where
    T: Debug + ?Sized, 

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

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

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

impl Debug for AtomicI64

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

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for isize

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

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

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

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

impl<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<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<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<A> Debug for Repeat<A> where
    A: Debug, 

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

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

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

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

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

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

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

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

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

impl<T> Debug for Discriminant<T>

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

impl Debug for AtomicI16

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

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

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

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

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

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

fn fmt(&self, __arg_0: &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, E, F, G, H, I, J, K, L> Debug for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

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

impl<T> Debug for AtomicPtr<T>

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

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

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

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

impl Debug for AtomicU16

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

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicI8

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

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

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

impl Debug for f32

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

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

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

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

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

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

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

impl<I> Debug for DecodeUtf8<I> where
    I: Iterator<Item = u8> + Debug, 

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

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

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

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

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

impl<T> Debug for [T; 16] 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 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 u8

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

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

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

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

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

impl<Ret, A, B, C, D, E, 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 PhantomData<T> where
    T: ?Sized, 

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

impl Debug for BorrowMutError

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 AtomicIsize

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

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

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

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

impl Debug for RangeFull

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

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

impl Debug for AtomicBool

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

impl Debug for AtomicU8

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

impl Debug for AtomicUsize

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

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

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

impl Debug for Ordering

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

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

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

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

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

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

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

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

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

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

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

impl Debug for u32

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

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

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

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

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

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

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

impl Debug for char

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

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

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

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

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

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

impl Debug for u16

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

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

impl Debug for AtomicU64

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

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

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

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

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

impl Debug for u64

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for SipHasher13

fn fmt(&self, __arg_0: &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<T10, T11> Debug for (T10, T11) where
    T10: Debug,
    T11: Debug + ?Sized, 

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

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

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

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

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

impl Debug for EscapeDefault

fn fmt(&self, __arg_0: &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<I, F> Debug for Map<I, F> where
    I: Debug, 

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

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

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

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

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

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

impl Debug for ()

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

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

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

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

impl Debug for ParseCharError

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for SipHasher24

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

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

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

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

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

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

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

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

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

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

impl Debug for AtomicI32

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

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

fn fmt(&self, __arg_0: &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<I> Debug for Skip<I> where
    I: Debug, 

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

impl<H> Debug for BuildHasherDefault<H>

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 FpCategory

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

impl Debug for TryFromIntError

fn fmt(&self, __arg_0: &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> Debug for unsafe extern "C" fn() -> 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] where
    T: Debug, 

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

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

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

impl Debug for f64

fn fmt(&self, fmt: &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<T> Debug for [T; 21] where
    T: 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<Ret, A, B, C, D, E, F, G, H, I, J> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

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

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

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

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

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

impl Debug for str

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

impl Debug for InvalidSequence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for i8

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

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

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

impl Debug for bool

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

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

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

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

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

impl Debug for Ordering

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

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

fn fmt(&self, __arg_0: &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<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<T> Debug for [T; 20] 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; 7] where
    T: Debug, 

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<T> Debug for NonZero<T> where
    T: Zeroable + Debug, 

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

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

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

impl Debug for i32

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

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

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

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

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

impl Debug for Alignment

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

impl Debug for i128

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

impl Debug for i64

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

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

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

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

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

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

impl Debug for Any + 'static + Send

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

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

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

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

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

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

impl Debug for AtomicU32

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

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

impl Debug for Uuid

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

impl Debug for ParseError

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

impl Debug for Builder

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

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

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

impl Debug for CpuPool

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

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

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

impl Debug for ParseFloatError

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

impl Debug for FloatErrorKind

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

impl Debug for UnsupportedPlatformError

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

impl Debug for Duration

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

impl Debug for SteadyTime

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

impl Debug for Timespec

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

impl Debug for ParseError

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

impl Debug for Tm

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

impl<'a> Debug for TmFmt<'a>

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

impl Debug for OutOfRangeError

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

impl<L, R> Debug for Either<L, R> where
    L: Debug,
    R: Debug, 

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

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

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

impl Debug for Canceled

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

impl<T> Debug for Sender<T>

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 Error

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

impl Debug for Context

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

impl Debug for Error

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

impl Debug for Template

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

impl Debug for Error

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

impl Debug for Data

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

impl Debug for TempDir

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

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

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

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

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

impl Debug for TryDemangleError

fn fmt(&self, __arg_0: &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 WriteAll<A, T> where
    A: Debug,
    T: Debug, 

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

impl<T, B> Debug for FramedWrite<T, B> where
    B: IntoBuf,
    T: Debug,
    <B as IntoBuf>::Buf: 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, __arg_0: &mut Formatter) -> Result<(), Error>

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

fn fmt(&self, __arg_0: &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<A> Debug for ReadUntil<A> where
    A: Debug, 

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

impl Debug for Builder

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

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

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

impl<T, B> Debug for Framed<T, B> where
    B: IntoBuf,
    T: Debug,
    <B as IntoBuf>::Buf: 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<T> Debug for FramedParts<T> where
    T: Debug, 

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

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

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

impl<R, T> Debug for Read<R, T> where
    R: Debug,
    T: Debug, 

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

impl<R, W> Debug for Copy<R, W> where
    R: Debug,
    W: Debug, 

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

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

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

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

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

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

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

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

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

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

fn fmt(&self, __arg_0: &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<T> Debug for Rc<T> where
    T: Debug + ?Sized, 

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

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

impl Debug for Heap

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

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

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

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

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

impl<'a, T> Debug for 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, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ParseError

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

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

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

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

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

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

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

impl Debug for String

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

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

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

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

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

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

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

impl<'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, __arg_0: &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 PlaceFront<'a, T> where
    T: 'a + Debug, 

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

impl Debug for Excess

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

impl Debug for CannotReallocInPlace

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

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

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

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

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

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

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

impl<'a, K, V> Debug for 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, T> Debug for BinaryHeapPlace<'a, T> where
    T: Ord + Clone + Debug, 

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

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

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

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

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

impl Debug for Layout

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

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

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

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

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

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

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

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

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

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

impl Debug for FromUtf16Error

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

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

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

impl Debug for AllocErr

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

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

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

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

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

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

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

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

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

impl<'a, T> Debug for Union<'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 BTreeSet<T> where
    T: Debug, 

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

impl Debug for Error

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

impl Debug for InvalidChunkSize

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

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

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

impl<'headers, 'buf> Debug for Request<'headers, 'buf> where
    'buf: 'headers, 

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

impl<'a> Debug for Header<'a>

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

impl<'headers, 'buf> Debug for Response<'headers, 'buf> where
    'buf: 'headers, 

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

impl Debug for Version

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

impl Debug for WildcardVersion

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

impl Debug for Predicate

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

impl Debug for VersionReq

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

impl Debug for Identifier

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

impl Debug for Op

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

impl Debug for Position

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

impl Debug for OpaqueOrigin

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

impl Debug for Url

Debug the serialization of this URL.

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

impl<'a> Debug for UrlQuery<'a>

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

impl Debug for ParseError

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

impl<T> Debug for Serializer<T> where
    T: Target + Debug, 

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

impl<'a> Debug for ByteSerialize<'a>

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

impl<'a> Debug for ParseOptions<'a>

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

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

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

impl Debug for Origin

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

impl<'a> Debug for Parse<'a>

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

impl<'a> Debug for PathSegmentsMut<'a>

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

impl<'a> Debug for ParseIntoOwned<'a>

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

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

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

impl Debug for SocketAddrs

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

impl Debug for Difference

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

impl<T> Debug for HttpsConnector<T>

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

impl<T> Debug for HttpsConnecting<T>

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

impl<T> Debug for MaybeHttpsStream<T>

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

impl Debug for SetReadiness

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

impl Debug for Poll

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

impl Debug for UnixReady

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

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

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

impl Debug for Registration

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

impl Debug for Token

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

impl Debug for TcpListener

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

impl Debug for Events

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

impl Debug for Event

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

impl Debug for PollOpt

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

impl Debug for UdpSocket

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

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

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

impl Debug for Ready

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

impl Debug for TcpStream

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

impl Debug for SetCookie

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

impl<B> Debug for Http<B>

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

impl Debug for PreferenceApplied

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

impl Debug for Encoding

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

impl Debug for Host

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

impl Debug for Cookie

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

impl Debug for AccessControlAllowHeaders

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

impl Debug for ReferrerPolicy

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

impl Debug for Vary

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

impl Debug for AcceptLanguage

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

impl Debug for Chunk

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

impl Debug for Te

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

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

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

impl Debug for DispositionType

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

impl Debug for UserAgent

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

impl Debug for LinkValue

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

impl Debug for IfUnmodifiedSince

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

impl Debug for Body

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

impl Debug for ContentDisposition

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

impl Debug for Quality

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

impl<S> Debug for Authorization<S> where
    S: Scheme + Debug, 

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

impl Debug for Referer

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

impl Debug for Response<Body>

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

impl Debug for DispositionParam

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

impl Debug for AccessControlExposeHeaders

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

impl Debug for Expires

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

impl Debug for FutureResponse

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

impl Debug for ContentLength

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

impl Debug for Bearer

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

impl Debug for Server

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

impl Debug for UseDefaultConnector

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

impl<'a> Debug for HeaderView<'a>

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

impl Debug for IfMatch

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

impl Debug for StrictTransportSecurity

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

impl Debug for Uri

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

impl Debug for LastModified

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

impl Debug for Protocol

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

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

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

impl Debug for RetryAfter

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

impl Debug for AcceptCharset

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

impl Debug for AccessControlAllowMethods

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

impl Debug for ProtocolName

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

impl Debug for CacheControl

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

impl Debug for AccessControlAllowCredentials

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

impl Debug for Warning

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

impl Debug for AccessControlRequestMethod

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

impl Debug for Prefer

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

impl Debug for LastEventId

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

impl Debug for AccessControlAllowOrigin

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

impl Debug for IfRange

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

impl<B> Debug for Request<B>

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

impl Debug for ExtendedValue

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

impl Debug for RangeUnit

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

impl Debug for ByteRangeSpec

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

impl Debug for IfNoneMatch

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

impl Debug for ContentLanguage

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

impl Debug for Allow

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

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

impl Debug for TransferEncoding

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

impl Debug for AcceptEncoding

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

impl Debug for Headers

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

impl Debug for AccessControlRequestHeaders

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

impl Debug for Error

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

impl Debug for EntityTag

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

impl Debug for Date

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

impl Debug for Basic

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

impl Debug for Accept

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

impl Debug for HttpVersion

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

impl Debug for AcceptRanges

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

impl Debug for StatusCode

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

impl Debug for MediaDesc

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

impl Debug for From

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

impl Debug for Origin

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

impl Debug for ConnectionOption

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

impl Debug for Preference

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

impl Debug for Range

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

impl Debug for ContentEncoding

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

impl Debug for Location

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

impl Debug for AccessControlMaxAge

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

impl<'a> Debug for CookieIter<'a>

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

impl Debug for Link

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

impl Debug for Method

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

impl Debug for ContentRange

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

impl Debug for CacheDirective

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

impl Debug for Upgrade

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

impl Debug for ContentLocation

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

impl Debug for Pragma

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

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

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

impl Debug for UriError

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

impl Debug for Expect

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

impl Debug for Charset

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

impl Debug for HttpConnector

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

impl Debug for Raw

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

impl Debug for HttpDate

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

impl Debug for ETag

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

impl Debug for ContentRangeSpec

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

impl Debug for IfModifiedSince

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

impl Debug for ContentType

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

impl Debug for RelationType

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

impl Debug for BodyError

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

impl Debug for Params

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

impl Debug for MediaType

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

impl Debug for Stream

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

impl Debug for Repeater

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

impl Debug for Expr

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

impl Debug for Literals

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

impl Debug for ByteClass

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

impl Debug for Lit

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

impl Debug for ErrorKind

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

impl Debug for Error

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

impl Debug for CharClass

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

impl Debug for ByteRange

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

impl Debug for ClassRange

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

impl Debug for ExprBuilder

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

impl Debug for Output

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

impl Debug for InitError

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

impl Debug for Dispatch

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

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

fn fmt(&self, __arg_0: &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 Connect<Kind, P>

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, __arg_0: &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<B> Debug for StreamingMultiplex<B> where
    B: Debug, 

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

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

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

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

fn fmt(&self, __arg_0: &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<B> Debug for StreamingPipeline<B> where
    B: Debug, 

fn fmt(&self, __arg_0: &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<T, B, E> Debug for MultiplexMessage<T, B, E> where
    B: Debug,
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &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<T, B, E> Debug for Frame<T, B, E> where
    B: Debug,
    E: Debug,
    T: Debug, 

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

impl Debug for FromStrError

fn fmt(&self, __arg_0: &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<A> Debug for TypeMap<A> where
    A: Debug + UnsafeAnyExt + ?Sized, 

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

impl Debug for Error

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

impl Debug for Body

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

impl Debug for Request

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

impl Debug for RequestBuilder

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

impl Debug for Proxy

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

impl Debug for Client

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

impl Debug for ClientBuilder

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

impl Debug for Response

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

impl Debug for RedirectPolicy

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

impl Debug for Certificate

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

impl<'a> Debug for RedirectAttempt<'a>

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

impl Debug for RedirectAction

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

impl<W> Debug for IntoInnerError<W>

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

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

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

impl<'a> Debug for SubCommand<'a>

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

impl<'a> Debug for ArgMatches<'a>

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

impl Debug for ErrorKind

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

impl<'a> Debug for ArgGroup<'a>

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

impl Debug for AppSettings

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

impl Debug for Shell

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

impl Debug for ArgSettings

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

impl Debug for Error

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

impl Debug for Errors

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

impl Debug for Sparse

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

impl Debug for Dense

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

impl<'a, R, P, A> Debug for StreamMatches<'a, R, P, A> where
    A: 'a + Automaton<P> + Debug + ?Sized,
    P: Debug,
    R: Debug, 

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

impl<'a, 's, P, A> Debug for MatchesOverlapping<'a, 's, P, A> where
    A: 'a + Automaton<P> + Debug + ?Sized,
    P: Debug, 

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

impl<'a, 's, P, A> Debug for Matches<'a, 's, P, A> where
    A: 'a + Automaton<P> + Debug + ?Sized,
    P: Debug, 

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

impl<P> Debug for FullAcAutomaton<P> where
    P: AsRef<[u8]> + Debug, 

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

impl<P, T> Debug for AcAutomaton<P, T> where
    P: AsRef<[u8]> + Debug,
    T: Transitions, 

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

impl Debug for Match

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

impl<'a, R, P, A> Debug for StreamMatchesOverlapping<'a, R, P, A> where
    A: 'a + Automaton<P> + Debug + ?Sized,
    P: Debug,
    R: Debug, 

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

impl Debug for OpensslString

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

impl Debug for Rsa

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

impl Debug for DigestBytes

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

impl Debug for OcspRevokedStatus

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

impl Debug for Nid

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

impl Debug for ShutdownResult

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

impl Debug for Dsa

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

impl Debug for SslVerifyMode

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

impl Debug for OcspCertStatus

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

impl Debug for OcspResponseStatus

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

impl Debug for ErrorStack

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

impl Debug for KeyError

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

impl Debug for BigNum

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

impl Debug for SslRef

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

impl Debug for SslOption

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

impl Debug for Error

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

impl Debug for BigNumRef

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

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

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

impl Debug for KeyIvPair

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

impl Debug for SslContext

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

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

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

impl Debug for Padding

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

impl Debug for Flag

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

impl Debug for X509VerifyError

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

impl Debug for SslMode

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

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

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

impl Debug for Ssl

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

impl Debug for OpensslStringRef

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

impl Debug for Error

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

impl Debug for Symbol

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

impl Debug for Frame

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

impl<'a> Debug for SymbolName<'a>

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

impl Debug for Backtrace

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

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

impl Debug for Stdio

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

impl Debug for CStr

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

impl Debug for IpAddr

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

impl Debug for TcpStream

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

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

impl Debug for SystemTimeError

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

impl Debug for FromBytesWithNulError

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

impl Debug for CString

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

impl Debug for SocketAddr

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

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

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

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

impl Debug for ChildStdout

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 LookupHost

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

impl Debug for UdpSocket

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

impl Debug for SystemTime

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

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

impl Debug for Child

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

impl Debug for Select

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

impl Debug for Duration

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

impl<T> Debug for TryLockError<T>

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 LocalKeyState

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

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

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

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

impl Debug for AddrParseError

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

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

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

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

impl Debug for Once

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

impl Debug for RandomState

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

impl Debug for Ipv6Addr

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

impl Debug for UnixDatagram

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

impl Debug for BarrierWaitResult

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

impl Debug for Builder

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

impl Debug for DefaultHasher

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

impl Debug for TcpListener

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 StripPrefixError

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

impl Debug for WaitTimeoutResult

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

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

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

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

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

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

impl Debug for Instant

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

impl Debug for Ipv6MulticastScope

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

impl Debug for TryRecvError

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

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

impl Debug for OnceState

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

impl Debug for UnixListener

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

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

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

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

impl Debug for OsStr

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

impl Debug for Shutdown

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

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

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

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

impl Debug for ThreadId

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

impl Debug for Thread

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

impl Debug for Condvar

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

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

impl<T> Debug for SendError<T>

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

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

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

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

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

impl<T> Debug for Key<T>

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

impl Debug for SocketAddr

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

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

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

impl Debug for RecvTimeoutError

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

impl Debug for EscapeDefault

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

impl Debug for UnixStream

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

impl<T> Debug for Receiver<T>

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

impl Debug for Ipv4Addr

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

impl Debug for c_void

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

impl Debug for ChildStdin

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

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

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

impl Debug for RecvError

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

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

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

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

impl<T> Debug for SyncSender<T>

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

impl Debug for AccessError

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

impl<T> Debug for PoisonError<T>

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

impl<T> Debug for JoinHandle<T>

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

impl<T> Debug for TrySendError<T>

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

impl<T> Debug for Sender<T>

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

impl Debug for SocketAddrV6

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

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

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

impl<'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<T> Debug for Key<T>

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

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

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 SocketAddrV4

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

impl Debug for NulError

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

impl Debug for ExitStatus

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

impl Debug for Error

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

impl Debug for Error

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

impl Debug for Value

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

impl Debug for DatetimeParseError

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

impl Debug for Datetime

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

impl Debug for RequestHead

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

impl Debug for IfRange

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

impl Debug for ProtocolName

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

impl Debug for AccessControlAllowHeaders

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

impl Debug for AccessControlRequestMethod

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

impl Debug for DispositionParam

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

impl Debug for Connection

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

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

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

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

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

impl Debug for HttpConnector

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

impl Debug for ExtendedValue

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

impl Debug for HttpDate

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

impl<'a, H> Debug for HeaderFormatter<'a, H> where
    H: HeaderFormat, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Upgrade

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for IfModifiedSince

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Referer

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RequestUri

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ReferrerPolicy

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, W> Debug for Response<'a, W> where
    W: Any + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for StatusClass

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Cookie

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Encoding

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AccessControlExposeHeaders

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Pragma

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ConnectionOption

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RelationType

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Authorization<S> where
    S: Scheme + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Location

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Origin

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ContentDisposition

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Prefer

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AccessControlMaxAge

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Accept

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptCharset

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ContentEncoding

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SetCookie

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for PooledStream<S> where
    S: Debug + 'static, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for CacheDirective

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ContentLength

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ContentRangeSpec

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ResponseHead

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Listening

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Charset

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Box<NetworkStream + 'static + Send>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for Date

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<L> Debug for Server<L> where
    L: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for StrictTransportSecurity

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptRanges

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AccessControlRequestHeaders

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for UserAgent

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Basic

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for DispositionType

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for HttpsStream<S> where
    S: NetworkStream + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Headers

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for HeaderView<'a>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Host

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Client

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ETag

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Bearer

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for IfNoneMatch

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ByteRangeSpec

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AccessControlAllowCredentials

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for HttpReader<R>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for StatusCode

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Allow

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RedirectPolicy

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for MediaDesc

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Method

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AccessControlAllowOrigin

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ContentLanguage

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W> Debug for HttpWriter<W> where
    W: Write, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S, C> Debug for HttpsConnector<S, C> where
    C: NetworkConnector + Debug,
    S: SslClient<HttpStream> + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ContentType

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for EntityTag

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Protocol

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ContentRange

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for TransferEncoding

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RawStatus

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Range

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for HttpVersion

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for IfUnmodifiedSince

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for From

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for HttpStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Http11Message

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Expect

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Vary

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Quality

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for PreferenceApplied

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RangeUnit

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for IfMatch

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for CacheControl

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for LastModified

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Link

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Preference

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AccessControlAllowMethods

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W> Debug for EndError<W> where
    W: Write + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Expires

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Server

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptLanguage

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Config

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for LinkValue

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptEncoding

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Response

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, __arg_0: &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 Number

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PrettyFormatter<'a>

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Category

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for CompactFormatter

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for FileTime

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, 'b> Debug for Formatter<'a, 'b>

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for FmtError

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Sign

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Alignment

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, V, F> Debug for UniqueBy<I, V, F> where
    I: Iterator + Debug,
    V: Debug + Hash + Eq, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for Unfold<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Combinations<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for Merge<I, J> where
    I: Iterator + Debug,
    J: Iterator<Item = <I as Iterator>::Item> + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, I, F> Debug for TakeWhileRef<'a, I, F> where
    I: Iterator + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, I> Debug for Format<'a, I> where
    I: Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for FoldWhile<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I> Debug for MultiPeek<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for EitherOrBoth<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<F> Debug for RepeatCall<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for Interleave<I, J> where
    I: Debug,
    J: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I> Debug for PutBack<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, J, F> Debug for MergeBy<I, J, F> where
    I: Iterator + Debug,
    J: Iterator<Item = <I as Iterator>::Item> + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<St, F> Debug for Iterate<St, F> where
    St: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for Coalesce<I, F> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for PutBackN<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for MinMaxResult<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, F> Debug for Batching<I, F> where
    I: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Unique<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Hash,
    <I as Iterator>::Item: Eq,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I, T> Debug for TupleCombinations<I, T> where
    I: Debug + Iterator,
    T: Debug + HasCombination<I>,
    <T as HasCombination<I>>::Combination: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for Flatten<I, J> where
    I: Debug,
    J: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Position<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I> Debug for WhileSome<I> where
    I: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Step<I> where
    I: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for Product<I, J> where
    I: Debug + Iterator,
    J: Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, J> Debug for InterleaveShortest<I, J> where
    I: Debug + Iterator,
    J: Debug + Iterator<Item = <I as Iterator>::Item>, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Dedup<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for _Unwind_Reason_Code

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for QUERY_ENCODE_SET

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for DEFAULT_ENCODE_SET

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SIMPLE_ENCODE_SET

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for PercentDecode<'a>

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for USERINFO_ENCODE_SET

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for PATH_SEGMENT_ENCODE_SET

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for PercentEncode<'a, E> where
    E: EncodeSet + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for LittleEndian

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for BigEndian

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for InputFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MQ_OFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for LioMode

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for LioOpcode

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for MemFdCreateFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EventFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for AioCb<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for MsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpMulticastLoop

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Linger

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ProtFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for KeepAlive

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SockFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpNoDelay

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6DropMembership

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for MntFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpAddMembership

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Mode

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SockType

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ReuseAddr

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for WaitPidFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Statvfs

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for FsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigevNotify

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for CloneFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SendTimeout

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for WaitStatus

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for TimeVal

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for QuotaValidFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for IpDropMembership

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for BaudRate

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Shutdown

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for LocalFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for MsgFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Statfs

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SocketError

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RcvBufForce

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for linger

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Ipv6AddMembership

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Errno

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for OFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AddressFamily

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for FdFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for EpollCreateFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SigEvent

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for EpollFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ControlFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Dqblk

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ReusePort

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SockType

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for MsFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FdFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for RcvBuf

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AcceptConn

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Signal

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for IpMulticastTtl

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RebootMode

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for TcpKeepIdle

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SndBufForce

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ReceiveTimeout

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for OobInline

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Broadcast

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SealFlag

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TimeSpec

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ucred

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SpliceFFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ip_mreq

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for OriginalDst

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for MapFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AioFsyncMode

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for OutputFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for AioCancelStat

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for PeerCredentials

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SaFlags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for SndBuf

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Flags

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for ThreadLocal<T> where
    T: Send + Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for CachedThreadLocal<T> where
    T: Send + 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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Slab<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for VacantEntry<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, T, R> Debug for Generator<'a, T, R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Isaac64Rng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StudentT

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 Debug for IsaacRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Gamma

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 XorShiftRng

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for LogNormal

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ChaChaRng

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'a, R> Debug for AsciiGenerator<'a, R> where
    R: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Normal

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<Sup> Debug for RandSample<Sup>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Exp1

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for FisherF

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<'a, T> Debug for WeightedChoice<'a, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for StandardNormal

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 ChiSquared

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for ReseedWithDefault

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for IsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for StringDeserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for SeqDeserializer<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for StrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UsizeDeserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F64Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, E> Debug for CowStrDeserializer<'a, E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U16Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I8Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for IgnoredAny

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I64Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Pair,
    <<I as Iterator>::Item as Pair>::Second: Debug, 

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I16Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for F32Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U32Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SeqAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for I32Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U64Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A> Debug for MapAccessDeserializer<A> where
    A: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for UnitDeserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for CharDeserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for U8Deserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for BoolDeserializer<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Unexpected<'a>

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ReqParseError

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for VersionReq

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Identifier

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SemVerError

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for GraphemeIncomplete

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Core

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for CoreId

fn fmt(&self, __arg_0: &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<E> Debug for PollEvented<E> where
    E: Debug + Evented, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Handle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Join<A, B> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<F> Debug for PollFn<F> where
    F: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ExecuteErrorKind

fn fmt(&self, __arg_0: &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<T, E> Debug for Empty<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Run

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Empty<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for LoopFn<A, F> where
    A: Debug + IntoFuture,
    F: Debug,
    <A as IntoFuture>::Future: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Skip<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for SinkMapErr<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Either<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for SpawnHandle<I, E>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for ExecuteError<F>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Async<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Concat<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Fuse<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Take<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Buffer<S> where
    S: Sink + Debug,
    <S as Sink>::SinkItem: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Flatten<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for SplitSink<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Flush<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B, C> Debug for Join3<A, B, C> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Execute<S> where
    S: Stream, 

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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Select2<A, B> where
    A: Debug,
    B: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I> Debug for JoinAll<I> where
    I: IntoIterator,
    <I as IntoIterator>::Item: IntoFuture,
    <<I as IntoIterator>::Item as IntoFuture>::Future: Debug,
    <<I as IntoIterator>::Item as IntoFuture>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S1, S2> Debug for Chain<S1, S2> where
    S1: Debug,
    S2: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<F> Debug for IntoStream<F> where
    F: Future + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Sender<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SelectOk<A> where
    A: Debug + Future, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for MapErr<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Task

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 Once<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Execute<S> where
    S: Stream, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for SpawnHandle<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<F> Debug for Execute<F> where
    F: Future + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I1, I2> Debug for MergedItem<I1, I2> where
    I1: Debug,
    I2: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Wait<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for BiLockGuard<'a, T> where
    T: 'a + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LocalKey<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Wait<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Repeat<T, E> where
    E: Debug,
    T: Debug + Clone, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, E> Debug for FromErr<A, E> where
    A: Debug + Future,
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for Map<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for FutureSender<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<F> Debug for FlattenStream<F> where
    F: Future + Debug,
    <F as Future>::Item: Stream,
    <F as Future>::Item: Debug,
    <<F as Future>::Item as Stream>::Error == <F as Future>::Error, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for Filter<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A> Debug for TaskRc<A> where
    A: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for Inspect<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<F> Debug for Shared<F> where
    F: Future + Debug,
    <F as Future>::Item: Debug,
    <F as Future>::Error: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for UnparkEvent

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A> Debug for SelectAll<A> where
    A: Debug + Future, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Spawn<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<I> Debug for IterResult<I> where
    I: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Peekable<S> where
    S: Stream + Debug,
    <S as Stream>::Item: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BiLock<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedSender<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for Then<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Send<S> where
    S: Sink + Debug,
    <S as Sink>::SinkItem: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for Collect<S> where
    S: Debug + Stream,
    <S as Stream>::Item: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Flatten<A> where
    A: Future + Debug,
    <A as Future>::Item: IntoFuture,
    <<A as IntoFuture>::Item as IntoFuture>::Future: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for Inspect<S, F> where
    F: Debug,
    S: Debug + Stream, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SharedItem<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<F> Debug for PollFn<F> where
    F: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for AndThen<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I> Debug for Iter<I> where
    I: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S1, S2> Debug for Select<S1, S2> where
    S1: Debug,
    S2: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for SelectNext<A, B> where
    A: Future + Debug,
    B: Debug + Future<Item = <A as Future>::Item, Error = <A as Future>::Error>, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BiLockAcquire<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, F> Debug for Map<A, F> where
    A: Debug + Future,
    F: Debug, 

fn fmt(&self, __arg_0: &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 MapErr<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B, C, D> Debug for Join4<A, B, C, D> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    D: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug,
    <D as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for FuturesUnordered<T> where
    T: Debug, 

fn fmt(&self, fmt: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for SendError<T>

fn fmt(&self, fmt: &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<F> Debug for Execute<F> where
    F: Future + Debug, 

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<A, B, F> Debug for OrElse<A, B, F> where
    A: Debug + Future,
    B: Debug + IntoFuture,
    F: Debug,
    <B as IntoFuture>::Future: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T, S> Debug for Loop<T, S> where
    S: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for StreamFuture<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for CatchUnwind<S> where
    S: Debug + Stream, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for SendError<T, E>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<F> Debug for CatchUnwind<F> where
    F: Debug + Future, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Receiver<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B> Debug for Select<A, B> where
    A: Future + Debug,
    B: Debug + Future<Item = <A as Future>::Item, Error = <A as Future>::Error>, 

fn fmt(&self, __arg_0: &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<T> Debug for SendError<T>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<S, F> Debug for FilterMap<S, F> where
    F: Debug,
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<I, E> Debug for IterOk<I, E> where
    E: Debug,
    I: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for BiLockAcquired<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<F, R> Debug for Lazy<F, R> where
    F: Debug,
    R: IntoFuture + Debug,
    <R as IntoFuture>::Future: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Canceled

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for NotifyHandle

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<S, E> Debug for FromErr<S, E> where
    E: Debug,
    S: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &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, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S, E> Debug for SinkFromErr<S, E> where
    E: Debug,
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for AtomicTask

fn fmt(&self, fmt: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for SplitStream<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for FuturesOrdered<T> where
    T: Debug + Future, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<E> Debug for SharedError<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A, B, C, D, E> Debug for Join5<A, B, C, D, E> where
    A: Future + Debug,
    B: Future<Error = <A as Future>::Error> + Debug,
    C: Future<Error = <A as Future>::Error> + Debug,
    D: Future<Error = <A as Future>::Error> + Debug,
    E: Future<Error = <A as Future>::Error> + Debug,
    <A as Future>::Item: Debug,
    <B as Future>::Item: Debug,
    <C as Future>::Item: Debug,
    <D as Future>::Item: Debug,
    <E as Future>::Item: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl<T> Debug for UnboundedReceiver<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<A> Debug for Fuse<A> where
    A: Future + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Sender<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for FutureResult<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Receiver<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AsyncSink<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &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, __arg_0: &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, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Params

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Output

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Failure

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Response

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Id

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Version

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Notification

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Request

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for MethodCall

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Call

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Success

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorCode

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for HyphenSplitter

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'w, 'a, S> Debug for WrapIter<'w, 'a, S> where
    'a: 'w,
    S: 'w + WordSplitter + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for NoHyphenation

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for IntoWrapIter<'a, S> where
    S: WordSplitter + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for Wrapper<'a, S> where
    S: WordSplitter + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W> Debug for GzEncoder<W> where
    W: Write + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for DeflateEncoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W> Debug for DeflateDecoder<W> where
    W: Write + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for DataError

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W> Debug for ZlibDecoder<W> where
    W: Write + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Builder

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for DeflateEncoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Decompress

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for DeflateDecoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Flush

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Header

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W> Debug for DeflateEncoder<W> where
    W: Write + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for GzDecoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Compress

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W> Debug for ZlibEncoder<W> where
    W: Write + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for MultiGzDecoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for MultiGzDecoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Crc

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for ZlibDecoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Status

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for GzDecoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for GzEncoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for CrcReader<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Compression

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for DeflateDecoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for ZlibEncoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for ZlibEncoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for ZlibDecoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for GzEncoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Void

fn fmt(&self, &mut Formatter) -> Result<(), Error>

impl<E> Debug for EncodeOptions<E> where
    E: Debug + Lz77Encode, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ExtraField

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Header

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W, E> Debug for Encoder<W, E> where
    E: Debug,
    W: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for HeaderBuilder

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T, E> Debug for Finish<T, E> where
    E: Debug,
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for DefaultLz77Encoder

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Lz77WindowSize

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for NoCompressionLz77Encoder

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Header

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Os

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<W, E> Debug for Encoder<W, E> where
    E: Debug,
    W: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for EncodeOptions<E> where
    E: Debug + Lz77Encode, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<E> Debug for EncodeOptions<E> where
    E: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionLevel

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionLevel

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<R> Debug for Decoder<R> where
    R: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Code

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for CompressionLevel

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Utf8Lossy

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for DecodeUtf16Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a> Debug for Utf8LossyChunk<'a>

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for UnicodeVersion

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for LanguageTag

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Attr

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SubLevel

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for TopLevel

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for Mime<T> where
    T: AsRef<[(Attr, Value)]> + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Value

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Units

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Infix

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Colour

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Suffix

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Style

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Prefix

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, S> Debug for ANSIGenericString<'a, S> where
    S: 'a + Debug + ToOwned + ?Sized,
    <S as ToOwned>::Owned: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Captures<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Match<'t>

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RegexSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SetMatches

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for RegexSet

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Debug for Regex

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Shows the original regular expression.

impl<'t> Debug for Captures<'t>

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<'t> Debug for Match<'t>

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for SetMatches

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Protocol

fn fmt(&self, __arg_0: &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<S> Debug for HandshakeError<S> where
    S: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<S> Debug for TlsStream<S> where
    S: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for ErrorKind

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<'a, T> Debug for Display<'a, T> where
    T: 'a + Debug + ?Sized, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl Debug for Error

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for LazyCell<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl<T> Debug for AtomicLazyCell<T> where
    T: Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

Implementors

• impl<'a, P> Debug for artifact_app::dev_prefix::str::SplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl<'a> Debug for artifact_app::dev_prefix::str::Lines<'a>
• impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>
• impl<'a, P> Debug for MatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl<'a> Debug for CharSearcher<'a>
• impl<T, E> Debug for Result<T, E> where
    E: Debug,
    T: Debug, 
• impl<'a> Debug for artifact_app::dev_prefix::str::Bytes<'a>
• impl<'a> Debug for artifact_app::dev_prefix::str::Chars<'a>
• impl<'a, P> Debug for RMatches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl<'a, P> Debug for RMatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl<'a, P> Debug for artifact_app::dev_prefix::str::RSplit<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl<'a, T> Debug for artifact_app::dev_prefix::result::Iter<'a, T> where
    T: 'a + Debug, 
• impl<'a, P> Debug for RSplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl Debug for Utf8Error
• impl Debug for ParseBoolError
• impl<T> Debug for artifact_app::dev_prefix::result::IntoIter<T> where
    T: Debug, 
• impl<'a, 'b> Debug for StrSearcher<'a, 'b>
• impl<'a, T> Debug for artifact_app::dev_prefix::result::IterMut<'a, T> where
    T: 'a + Debug, 
• impl<'a> Debug for LinesAny<'a>
• impl<'a, P> Debug for artifact_app::dev_prefix::str::Matches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl<'a, F> Debug for CharPredicateSearcher<'a, F> where
    F: FnMut(char) -> bool, 
• impl<'a> Debug for Arguments<'a>
• impl Debug for SearchStep
• impl<'a> Debug for CharIndices<'a>
• impl Debug for !
• impl<'a, P> Debug for artifact_app::dev_prefix::str::Split<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl Debug for artifact_app::dev_prefix::fmt::Error
• impl<'a, P> Debug for artifact_app::dev_prefix::str::RSplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl<'a, P> Debug for SplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 
• impl<'a> Debug for EncodeUtf16<'a>
• impl<T> Debug for VecDeque<T> where
    T: Debug, 
• impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 
• impl<B> Debug for artifact_app::dev_prefix::io::Lines<B> where
    B: Debug, 
• impl<T, S> Debug for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash + Debug, 
• impl Debug for VarError
• impl<B> Debug for artifact_app::dev_prefix::io::Split<B> where
    B: Debug, 
• impl<T> Debug for Cursor<T> where
    T: Debug, 
• impl Debug for artifact_app::dev_prefix::io::Error
• impl Debug for OpenOptions
• impl Debug for SeekFrom
• impl Debug for FileType
• impl<W> Debug for LineWriter<W> where
    W: Write + Debug, 
• impl Debug for Stderr
• impl<R> Debug for artifact_app::dev_prefix::io::Chars<R> where
    R: Debug, 
• impl<'a> Debug for SplitPaths<'a>
• impl Debug for Args
• impl<W> Debug for BufWriter<W> where
    W: Write + Debug, 
• impl Debug for Vars
• impl Debug for Initializer
• impl Debug for Stdin
• impl Debug for Sink
• impl<T> Debug for artifact_app::dev_prefix::io::Take<T> where
    T: Debug, 
• impl Debug for File
• impl<R> Debug for BufReader<R> where
    R: Debug, 
• impl Debug for DirBuilder
• impl Debug for Stdout
• impl<R> Debug for artifact_app::dev_prefix::io::Bytes<R> where
    R: Debug, 
• impl Debug for artifact_app::dev_prefix::io::ErrorKind
• impl Debug for Path
• impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Eq + Hash + Debug,
    S: BuildHasher,
    V: Debug, 
• impl Debug for OsString
• impl Debug for PathBuf
• impl<'a> Debug for StdoutLock<'a>
• impl Debug for artifact_app::dev_prefix::io::Empty
• impl Debug for Metadata
• impl<W> Debug for artifact_app::dev_prefix::io::IntoInnerError<W> where
    W: Debug, 
• impl<'a> Debug for StdinLock<'a>
• impl Debug for VarsOs
• impl Debug for artifact_app::dev_prefix::io::Repeat
• impl Debug for JoinPathsError
• impl Debug for ReadDir
• impl<T, U> Debug for artifact_app::dev_prefix::io::Chain<T, U> where
    T: Debug,
    U: Debug, 
• impl<'a> Debug for StderrLock<'a>
• impl Debug for Permissions
• impl Debug for ArgsOs
• impl Debug for CharsError
• impl Debug for DirEntry
• impl<'a> Debug for SplitWhitespace<'a>
• impl Debug for artifact_app::dev_prefix::Regex
• impl Debug for artifact_app::types::Error
• impl Debug for artifact_app::types::ErrorKind
• impl Debug for Project
• impl Debug for Type
• impl Debug for Loc
• impl Debug for Done
• impl Debug for Artifact
• impl Debug for Settings
• impl Debug for ServeCmd
• impl Debug for ProjectText
• impl Debug for artifact_app::types::Name
• impl Debug for LocData
• impl Debug for ArtifactData
• impl Debug for ProjectData
• impl Debug for FmtSettings
• impl Debug for FmtArtifact
• impl Debug for PercentSearch
• impl Debug for SearchSettings