Trait tract_pulse::internal::fmt::Debug

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

? formatting.

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

Generally speaking, you should just derive a Debug implementation.

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

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

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

Stability

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

Examples

Deriving an implementation:

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

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

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

Manually implementing:

use std::fmt;

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

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

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

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

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

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

Pretty-printing with #?:

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

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

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

Required methods

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

Formats the value using the given formatter.

Examples

use std::fmt;

struct Position {
    longitude: f32,
    latitude: f32,
}

impl fmt::Debug for Position {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_tuple("")
         .field(&self.longitude)
         .field(&self.latitude)
         .finish()
    }
}

let position = Position { longitude: 1.987, latitude: 2.983 };
assert_eq!(format!("{:?}", position), "(1.987, 2.983)");

assert_eq!(format!("{:#?}", position), "(
    1.987,
    2.983,
)");

Loading content...

Implementations on Foreign Types

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

pub 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

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

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

pub 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

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

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

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

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

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

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

pub 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

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

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

pub 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

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

impl Debug for u16

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

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

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

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

pub 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

pub 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

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

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

pub 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

pub 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

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

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

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

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

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

impl Debug for bool

pub 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,
    T2: Debug,
    T3: Debug,
    T4: Debug,
    T5: Debug,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug,
    T10: Debug,
    T11: Debug + ?Sized, 

pub 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

pub 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

pub 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

pub 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

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

impl Debug for f32

pub fn fmt(&self, fmt: &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
    T2: Debug,
    T3: Debug,
    T4: Debug,
    T5: Debug,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug,
    T10: Debug,
    T11: Debug + ?Sized, 

pub 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,
    T2: Debug,
    T3: Debug,
    T4: Debug,
    T5: Debug,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug,
    T10: Debug,
    T11: Debug + ?Sized, 

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

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

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

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

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

impl Debug for str

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

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

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

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

pub 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

pub 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

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

impl Debug for Utf8Lossy

pub 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

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

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

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

impl Debug for u128

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

impl Debug for !

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

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

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

impl Debug for i16

pub 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

pub 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

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

impl Debug for char

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

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

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

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

pub 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

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

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

pub 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

pub 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

pub 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

pub 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

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

impl Debug for f64

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

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

pub 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

pub 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

pub 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

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

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

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

impl Debug for i32

pub 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

pub 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

pub 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

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

impl Debug for isize

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

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

pub 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

pub 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

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

impl Debug for i128

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

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

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

impl Debug for usize

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

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

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

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

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

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

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

impl Debug for u8

pub 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

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

impl Debug for i64

pub 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

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

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

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

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

pub 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

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

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

pub 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

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

impl Debug for ()

pub 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

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

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

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

impl Debug for u32

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

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

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

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

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

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

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

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

pub 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
    T3: Debug,
    T4: Debug,
    T5: Debug,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug,
    T10: Debug,
    T11: Debug + ?Sized, 

pub 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
    T4: Debug,
    T5: Debug,
    T6: Debug,
    T7: Debug,
    T8: Debug,
    T9: Debug,
    T10: Debug,
    T11: Debug + ?Sized, 

pub 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

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

impl Debug for u64

pub 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

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

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

pub 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

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

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

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

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

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

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

pub 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

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

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

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

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

pub 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

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

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

pub 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

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

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

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

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

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

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

pub 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

pub 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

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

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

pub 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

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

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

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

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

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

impl Debug for i8

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

impl Debug for _Unwind_Reason_Code

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

impl Debug for PulsePad

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

impl Debug for Delay

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

impl Debug for TypeSpec

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

impl Debug for LValue

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

impl Debug for ProtoModel

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

impl Debug for IfThenElse

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

impl Debug for GraphDef

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

impl Debug for Result_

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

impl Debug for Comprehension

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

impl Debug for Assignment

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

impl Debug for Document

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

impl Debug for Value

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

impl Debug for Subscript

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

impl Debug for Literal

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

impl Debug for Invocation

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

impl Debug for Argument

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

impl<'a> Debug for MetadataBuilder<'a>

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

impl Debug for Level

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

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

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

impl Debug for ParseLevelError

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

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

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

impl Debug for LevelFilter

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

impl<'a> Debug for RecordBuilder<'a>

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

impl Debug for SetLoggerError

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

impl<B> Debug for BitSet<B> where
    B: BitBlock, 

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

impl<B> Debug for BitVec<B> where
    B: BitBlock, 

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

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

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

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

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

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

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

impl<'a, I, E> Debug for ProcessResults<'a, I, E> where
    E: 'a + Debug,
    I: Debug, 

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

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

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

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

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

impl<I, J> Debug for InterleaveShortest<I, J> where
    I: Debug + Iterator,
    J: Debug + Iterator<Item = <I as Iterator>::Item>, 

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

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

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

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

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

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

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

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

impl<I, T> Debug for TupleCombinations<I, T> where
    T: Debug + HasCombination<I>,
    I: Debug + Iterator,
    <T as HasCombination<I>>::Combination: Debug, 

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

impl<I, J> Debug for Interleave<I, J> where
    I: Debug,
    J: Debug, 

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

impl<I, T> Debug for TupleWindows<I, T> where
    T: Debug + TupleCollect,
    I: Debug + Iterator<Item = <T as TupleCollect>::Item>, 

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

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

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

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

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

impl<I, J> Debug for ZipEq<I, J> where
    I: Debug,
    J: Debug, 

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

impl<I, J> Debug for ConsTuples<I, J> where
    I: Debug + Iterator<Item = J>,
    J: Debug, 

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

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

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

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

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

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

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

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

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

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

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

impl<T> Debug for TupleBuffer<T> where
    T: Debug + TupleCollect,
    <T as TupleCollect>::Buffer: Debug, 

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

impl<F> Debug for RepeatCall<F>

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

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

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

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

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

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

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

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

impl<I, J, F> Debug for MergeJoinBy<I, J, F> where
    I: Iterator + Debug,
    J: Iterator + Debug,
    <I as Iterator>::Item: Debug,
    <J as Iterator>::Item: Debug, 

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

impl<'a, I, F> Debug for TakeWhileRef<'a, I, F> where
    I: Iterator + Debug, 

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

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

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

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

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

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

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

impl Debug for bf16

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

impl Debug for f16

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

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

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

impl Debug for Endianness

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

impl Debug for CompareResult

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

impl Debug for ErrorKind

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

impl Debug for VerboseErrorKind

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

impl Debug for Needed

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

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

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

impl Debug for Error

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

impl Debug for ErrorCode

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

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

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

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

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

impl<T> Debug for CapacityError<T>

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

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

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

impl Debug for LittleEndian

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

impl Debug for BigEndian

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

impl Debug for UstarHeader

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

impl Debug for GnuSparseHeader

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

impl Debug for Header

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

impl Debug for Unpacked

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

impl Debug for HeaderMode

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

impl Debug for EntryType

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

impl Debug for OldHeader

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

impl Debug for GnuHeader

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

impl Debug for FileTime

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

impl Debug for UnsupportedPlatformError

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

impl Debug for Error

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

impl Debug for DirEntry

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

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

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

impl Debug for WalkDir

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

impl Debug for IntoIter

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

impl Debug for Handle

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

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

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

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

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

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

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

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

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

impl Debug for DecompressError

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

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

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

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

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

impl Debug for GzHeader

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Debug for CompressError

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

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

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

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

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

impl Debug for Crc

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

impl Debug for Decompress

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

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

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

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

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

impl Debug for Compression

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

impl Debug for FlushDecompress

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

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

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

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

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

impl Debug for GzBuilder

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

impl Debug for FlushCompress

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

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

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

impl Debug for Compress

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

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

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

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

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

impl Debug for Status

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

impl Debug for Hasher

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

impl Debug for TDEFLStatus

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

impl Debug for MZFlush

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

impl Debug for MZStatus

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

impl Debug for DataFormat

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

impl Debug for CompressionLevel

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

impl Debug for CompressionStrategy

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

impl Debug for MZError

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

impl Debug for StreamResult

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

impl Debug for TINFLStatus

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

impl Debug for TDEFLFlush

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

impl Debug for Adler32

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

Loading content...

Implementors

impl Debug for AttrOrInput

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

impl Debug for AxisOp

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

impl Debug for Cost

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

impl Debug for DatumType

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

impl Debug for InOut

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

impl Debug for RValue

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

impl Debug for TDim

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

impl Debug for TypeName

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

impl Debug for Validation

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

impl Debug for ConcatSlice

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

impl Debug for PadMode

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

impl Debug for KernelFormat

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

impl Debug for PaddingSpec

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

impl Debug for ProtoFusedSpec

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::DataFormat

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

impl Debug for Reducer

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

impl Debug for Alignment

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

impl Debug for SearchStep

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

impl Debug for CollectionAllocErr

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

impl Debug for BacktraceStatus

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::cmp::Ordering

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

impl Debug for TryReserveError

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

impl Debug for Infallible

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

impl Debug for VarError

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::ErrorKind

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

impl Debug for SeekFrom

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

impl Debug for IpAddr

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

impl Debug for Ipv6MulticastScope

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

impl Debug for Shutdown

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::net::SocketAddr

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

impl Debug for FpCategory

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

impl Debug for IntErrorKind

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

impl Debug for c_void

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

impl Debug for AncillaryError

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::sync::atomic::Ordering

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

impl Debug for RecvTimeoutError

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

impl Debug for TryRecvError

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

impl Debug for LinearSpec

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

impl Debug for MatrixStoreSpec

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

impl Debug for PanelStore

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_ndarray::ErrorKind

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

impl Debug for SliceOrIndex

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

impl Debug for FloatErrorKind

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

impl Debug for InputMapping

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

impl Debug for StateInitializer

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

impl Debug for PulsedFact

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

impl Debug for AxisChange

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

impl Debug for AxisChangeConsequence

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

impl Debug for AxisInfo

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

impl Debug for AxisTracking

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

impl Debug for Blob

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

impl Debug for Dims

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

impl Debug for FragmentDecl

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

impl Debug for FragmentDef

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

impl Debug for InletId

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

impl Debug for Invariants

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

impl Debug for OutletId

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

impl Debug for Parameter

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

impl Debug for SessionState

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

impl Debug for ShapeFact

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

impl Debug for Symbol

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

impl Debug for SymbolValues

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

impl Debug for Tensor

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

impl Debug for TypedFact

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

impl Debug for tract_pulse::internal::f16

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

impl Debug for ConstantOfShape

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

impl Debug for FiniteReshape

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

impl Debug for Gather

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

impl Debug for MultiBroadcastTo

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

impl Debug for OneHot

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

impl Debug for Pad

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

impl Debug for tract_pulse::internal::tract_core::ops::array::Slice

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

impl Debug for Tile

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

impl Debug for TypedConcat

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

impl Debug for MergeOpUnicast

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

impl Debug for TypedBinOp

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

impl Debug for UnaryOp

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

impl Debug for Cast

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

impl Debug for Im2Col

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

impl Debug for ConvUnary

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

impl Debug for MaxPool

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

impl Debug for Patch

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

impl Debug for PatchAxis

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

impl Debug for PatchSpec

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

impl Debug for PoolSpec

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

impl Debug for SumPool

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

impl Debug for Dummy

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

impl Debug for ElementWiseOp

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

impl Debug for Identity

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

impl Debug for Const

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

impl Debug for And

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

impl Debug for Equals

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

impl Debug for Greater

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

impl Debug for GreaterEqual

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

impl Debug for Iff

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

impl Debug for Lesser

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

impl Debug for LesserEqual

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

impl Debug for Not

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

impl Debug for NotEquals

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

impl Debug for Or

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

impl Debug for Xor

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

impl Debug for Abs

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

impl Debug for Acos

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

impl Debug for Acosh

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

impl Debug for Add

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

impl Debug for Asin

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

impl Debug for Asinh

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

impl Debug for Atan

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

impl Debug for Atanh

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

impl Debug for Ceil

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

impl Debug for Cos

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

impl Debug for Cosh

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

impl Debug for Div

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

impl Debug for Exp

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

impl Debug for FlippedPow

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

impl Debug for FlippedShiftLeft

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

impl Debug for FlippedShiftRight

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

impl Debug for Floor

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

impl Debug for Ln

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

impl Debug for Max

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

impl Debug for Min

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

impl Debug for Mul

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

impl Debug for Neg

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

impl Debug for Pow

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

impl Debug for Recip

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

impl Debug for Rem

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

impl Debug for Round

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

impl Debug for RoundHalfToEven

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

impl Debug for Rsqrt

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

impl Debug for ShiftLeft

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

impl Debug for ShiftRight

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

impl Debug for Sign

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

impl Debug for Sin

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

impl Debug for Sinh

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

impl Debug for Sqrt

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

impl Debug for Square

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

impl Debug for Sub

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

impl Debug for Tan

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

impl Debug for Tanh

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

impl Debug for LirMatMulUnary

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

impl Debug for MatMatMulPack

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

impl Debug for MatMul

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

impl Debug for MatMulUnary

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

impl Debug for QMatMul

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

impl Debug for QParams

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

impl Debug for Reduce

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

impl Debug for Sigmoid

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::anyhow::Error

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::fmt::Error

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

impl Debug for ParseBoolError

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

impl Debug for Utf8Error

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

impl Debug for FromUtf8Error

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

impl Debug for FromUtf16Error

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

impl Debug for AllocError

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

impl Debug for Global

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

impl Debug for Layout

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

impl Debug for LayoutError

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

impl Debug for System

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

impl Debug for TypeId

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

impl Debug for CpuidResult

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

impl Debug for __m128

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

impl Debug for __m128d

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

impl Debug for __m128i

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

impl Debug for __m256

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

impl Debug for __m256d

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

impl Debug for __m256i

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

impl Debug for __m512

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

impl Debug for __m512d

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

impl Debug for __m512i

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

impl Debug for TryFromSliceError

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::ascii::EscapeDefault

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

impl Debug for Backtrace

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

impl Debug for BacktraceFrame

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

impl Debug for BorrowError

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

impl Debug for BorrowMutError

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

impl Debug for CharTryFromError

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

impl Debug for DecodeUtf16Error

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::char::EscapeDebug

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::char::EscapeDefault

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::char::EscapeUnicode

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

impl Debug for ParseCharError

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

impl Debug for ToLowercase

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

impl Debug for ToUppercase

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

impl Debug for DefaultHasher

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

impl Debug for RandomState

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

impl Debug for Args

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

impl Debug for ArgsOs

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

impl Debug for JoinPathsError

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

impl Debug for Vars

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

impl Debug for VarsOs

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

impl Debug for CStr

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

impl Debug for CString

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

impl Debug for FromBytesWithNulError

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

impl Debug for FromVecWithNulError

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

impl Debug for IntoStringError

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

impl Debug for NulError

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

impl Debug for OsStr

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

impl Debug for OsString

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

impl Debug for DirBuilder

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::fs::DirEntry

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

impl Debug for File

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

impl Debug for FileType

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::fs::Metadata

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

impl Debug for OpenOptions

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

impl Debug for Permissions

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

impl Debug for ReadDir

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

impl Debug for SipHasher

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Empty

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Error

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

impl Debug for Initializer

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Repeat

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

impl Debug for Sink

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

impl Debug for Stderr

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

impl Debug for Stdin

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

impl Debug for Stdout

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

impl Debug for PhantomPinned

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

impl Debug for AddrParseError

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

impl Debug for Ipv4Addr

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

impl Debug for Ipv6Addr

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

impl Debug for SocketAddrV4

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

impl Debug for SocketAddrV6

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

impl Debug for TcpListener

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

impl Debug for TcpStream

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

impl Debug for UdpSocket

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

impl Debug for NonZeroI8

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

impl Debug for NonZeroI16

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

impl Debug for NonZeroI32

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

impl Debug for NonZeroI64

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

impl Debug for NonZeroI128

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

impl Debug for NonZeroIsize

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

impl Debug for NonZeroU8

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

impl Debug for NonZeroU16

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

impl Debug for NonZeroU32

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

impl Debug for NonZeroU64

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

impl Debug for NonZeroU128

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

impl Debug for NonZeroUsize

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::num::ParseFloatError

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

impl Debug for ParseIntError

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

impl Debug for TryFromIntError

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

impl Debug for RangeFull

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

impl Debug for NoneError

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::os::unix::net::SocketAddr

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

impl Debug for UnixDatagram

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

impl Debug for UnixListener

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

impl Debug for UnixStream

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

impl Debug for UCred

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

impl Debug for Path

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

impl Debug for PathBuf

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

impl Debug for StripPrefixError

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

impl Debug for String

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

impl Debug for Child

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

impl Debug for ChildStderr

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

impl Debug for ChildStdin

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

impl Debug for ChildStdout

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

impl Debug for Command

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

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

impl Debug for ExitStatus

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

impl Debug for Output

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

impl Debug for Stdio

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

impl Debug for AtomicBool

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

impl Debug for AtomicI8

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

impl Debug for AtomicI16

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

impl Debug for AtomicI32

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

impl Debug for AtomicI64

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

impl Debug for AtomicIsize

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

impl Debug for AtomicU8

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

impl Debug for AtomicU16

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

impl Debug for AtomicU32

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

impl Debug for AtomicU64

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

impl Debug for AtomicUsize

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

impl Debug for RecvError

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

impl Debug for Barrier

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

impl Debug for BarrierWaitResult

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

impl Debug for Condvar

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::sync::Once

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

impl Debug for OnceState

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

impl Debug for WaitTimeoutResult

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

impl Debug for RawWaker

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

impl Debug for RawWakerVTable

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

impl Debug for Waker

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

impl Debug for AccessError

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

impl Debug for Builder

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

impl Debug for Thread

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

impl Debug for ThreadId

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

impl Debug for Duration

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

impl Debug for Instant

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

impl Debug for SystemTime

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

impl Debug for SystemTimeError

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

impl Debug for Packer

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

impl Debug for MatMatMulF32x16x6

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

impl Debug for MatMatMulI8x8x8

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

impl Debug for MatMatMulI8xI32x8x8

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

impl Debug for SigmoidF32

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

impl Debug for TanhF32

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

impl Debug for Axis

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

impl Debug for AxisDescription

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

impl Debug for IxDynImpl

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

impl Debug for ShapeError

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_ndarray::Slice

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

impl Debug for tract_pulse::internal::tract_core::ops::nn::tract_num_traits::ParseFloatError

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

impl Debug for IntoTranslator

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

impl Debug for DequantizeLinearF32

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

impl Debug for LookupTable

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

impl Debug for QuantizeLinearI8

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

impl Debug for QuantizeLinearU8

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

impl Debug for Scale

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

impl Debug for LirScan

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

impl Debug for tract_pulse::internal::tract_core::ops::scan::Scan

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

impl Debug for SourceState

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

impl Debug for TypedSource

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

impl Debug for Downsample

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

impl Debug for UnimplementedOp

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

impl Debug for ChangeAxes

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

impl Debug for PulsedSource

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

impl Debug for dyn Any + 'static

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

impl Debug for dyn Any + 'static + Send

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

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

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

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

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

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

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

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

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

impl<'_> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::string::Drain<'_>

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'_> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::path::Iter<'_>

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

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

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

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

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

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

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

impl<'_, K> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_set::Drain<'_, K> where
    K: Debug, 

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

impl<'_, K> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_set::Iter<'_, K> where
    K: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::Entry<'_, K, V> where
    K: Debug + Ord,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::Entry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::Keys<'_, K, V> where
    K: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::OccupiedEntry<'_, K, V> where
    K: Debug + Ord,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::OccupiedError<'_, K, V> where
    K: Debug + Ord,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::Range<'_, K, V> where
    K: Debug,
    V: Debug, 

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

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

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::VacantEntry<'_, K, V> where
    K: Debug + Ord, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::Values<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::ValuesMut<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::Drain<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::Iter<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::IterMut<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::Keys<'_, K, V> where
    K: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::OccupiedEntry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::OccupiedError<'_, K, V> where
    K: Debug,
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::VacantEntry<'_, K, V> where
    K: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::Values<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::ValuesMut<'_, K, V> where
    V: Debug, 

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

impl<'_, K, V, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::DrainFilter<'_, K, V, F> where
    F: FnMut(&K, &mut V) -> bool,
    K: Debug,
    V: Debug, 

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

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

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

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

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

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

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

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

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

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

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::binary_heap::Iter<'_, T> where
    T: Debug, 

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

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

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_set::Difference<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_set::Intersection<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_set::Iter<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_set::SymmetricDifference<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_set::Union<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::linked_list::Cursor<'_, T> where
    T: Debug, 

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

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

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::linked_list::Iter<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::linked_list::IterMut<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::vec_deque::Drain<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::vec_deque::Iter<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::vec_deque::IterMut<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::slice::Iter<'_, T> where
    T: Debug, 

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

impl<'_, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::slice::IterMut<'_, T> where
    T: Debug, 

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

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

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

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

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

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

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

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

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

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

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

impl<'_, T, A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::vec::Drain<'_, T, A> where
    T: Debug,
    A: Allocator, 

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

impl<'_, T, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_set::DrainFilter<'_, T, F> where
    T: Debug,
    F: FnMut(&T) -> bool, 

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

impl<'_, T, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::linked_list::DrainFilter<'_, T, F> where
    T: Debug,
    F: FnMut(&mut T) -> bool, 

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

impl<'_, T, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::slice::RSplit<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

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

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

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

impl<'_, T, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::slice::RSplitN<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

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

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

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

impl<'_, T, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::slice::Split<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

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

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

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

impl<'_, T, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::slice::SplitN<'_, T, P> where
    T: Debug,
    P: FnMut(&T) -> bool, 

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

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

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

impl<'_, T, S> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_set::Difference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, T, S> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_set::Intersection<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, T, S> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_set::SymmetricDifference<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

impl<'_, T, S> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_set::Union<'_, T, S> where
    S: BuildHasher,
    T: Debug + Eq + Hash, 

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

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

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

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

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

impl<'a> Debug for TensorView<'a>

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

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

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

impl<'a> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::Bytes<'a>

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

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

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

impl<'a> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::EscapeDebug<'a>

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

impl<'a> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::EscapeDefault<'a>

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

impl<'a> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::EscapeUnicode<'a>

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

impl<'a> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::Lines<'a>

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

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

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

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

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

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

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

impl<'a> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::error::Chain<'a>

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

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

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

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

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

impl<'a> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::net::Incoming<'a>

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

impl<'a> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::os::unix::net::Incoming<'a>

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

impl<'a> Debug for SocketAncillary<'a>

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

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

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

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

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

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

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

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

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

impl<'a> Debug for CommandArgs<'a>

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

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

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

impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

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

impl<'a, 'b> Debug for StrSearcher<'a, 'b>

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

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

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

impl<'a, A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::option::Iter<'a, A> where
    A: 'a + Debug, 

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

impl<'a, A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::option::IterMut<'a, A> where
    A: 'a + Debug, 

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

impl<'a, A, D> Debug for AxisIter<'a, A, D> where
    D: Debug,
    A: Debug, 

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

impl<'a, A, S, D> Debug for ArrayBase<S, D> where
    S: Data<Elem = A>,
    D: Dimension,
    A: Debug, 

Format the array using Debug and apply the formatting parameters used to each element.

The array is shown in multiline style.

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

impl<'a, D> Debug for Axes<'a, D> where
    D: Debug, 

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

impl<'a, I> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Format<'a, I> where
    I: Iterator,
    <I as Iterator>::Item: Debug, 

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

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

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I, E> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::ProcessResults<'a, I, E> where
    E: 'a + Debug,
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, I, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::TakeWhileRef<'a, I, F> where
    I: Iterator + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, K, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_set::DrainFilter<'a, K, F> where
    F: FnMut(&K) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::IterMut<'a, K, V> where
    K: 'a + Debug,
    V: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, K, V, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::DrainFilter<'a, K, V, F> where
    F: FnMut(&K, &mut V) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for MatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for Matches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for RMatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for RMatches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::RSplit<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::RSplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for RSplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::Split<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::SplitInclusive<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::str::SplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, P> Debug for SplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::binary_heap::Drain<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for DrainSorted<'a, T> where
    T: Debug + Ord, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_set::Range<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Chunks<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ChunksExact<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ChunksExactMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for ChunksMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RChunks<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RChunksExact<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RChunksExactMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for RChunksMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for Windows<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::Drain<'a, T> where
    T: 'a + Array,
    <T as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::result::Iter<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::result::IterMut<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::sync::mpsc::Iter<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T> Debug for TryIter<'a, T> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, F, A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::vec::DrainFilter<'a, T, F, A> where
    T: Debug,
    A: Debug + Allocator,
    F: Debug + FnMut(&mut T) -> bool, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, P> Debug for GroupBy<'a, T, P> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, P> Debug for GroupByMut<'a, T, P> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, const N: usize> Debug for ArrayChunks<'a, T, N> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, const N: usize> Debug for ArrayChunksMut<'a, T, N> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, const N: usize> Debug for ArrayWindows<'a, T, N> where
    T: 'a + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, TI> Debug for MatMatMulKerSpec<'a, TI> where
    TI: Debug + Copy, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'f> Debug for VaListImpl<'f>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'p, T> Debug for KInWriter<'p, T> where
    T: Debug + Copy, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'p, T> Debug for KOutWriter<'p, T> where
    T: Debug + Copy, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'s, 't> Debug for MatrixStore<'s, 't>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'t> Debug for FusedSpec<'t>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::IntoIter<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::option::IntoIter<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::__std_iter::Repeat<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::RepeatN<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for OwnedArcRepr<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A> Debug for OwnedRepr<A> where
    A: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::EitherOrBoth<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::__std_iter::Chain<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<A, B> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::__std_iter::Zip<A, B> where
    A: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Lines<B> where
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Split<B> where
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<B, C> Debug for ControlFlow<B, C> where
    C: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Indices<D> where
    D: Debug + Dimension, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for Shape<D> where
    D: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D> Debug for StrideShape<D> where
    D: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<D, S> Debug for BaseDataShape<D, S> where
    S: Debug + AsRef<[D]>,
    D: Debug + DimLike, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Dyn> Debug for DynMetadata<Dyn> where
    Dyn: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for Outlet<F> where
    F: Fact + Hash, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for PollFn<F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for FromFn<F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for OnceWith<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for RepeatWith<F> where
    F: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::RepeatCall<F>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F> Debug for OutputMapping<F> where
    F: Clone + Display, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<F, O> Debug for Graph<F, O> where
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    F: Debug + Fact + Hash + Clone + 'static, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F, O> Debug for ModelPatch<F, O> where
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    F: Debug + Fact + Clone + 'static + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F, O> Debug for Node<F, O> where
    O: Debug + Hash,
    F: Debug + Fact + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F, O, M> Debug for SimplePlan<F, O, M> where
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    F: Debug + Fact + Hash + Clone + 'static,
    M: Debug + Borrow<Graph<F, O>> + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<F, O, M, P> Debug for SimpleState<F, O, M, P> where
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    F: Debug + Fact + Hash + Clone + 'static,
    P: Debug + Borrow<SimplePlan<F, O, M>>,
    M: Debug + Borrow<Graph<F, O>> + Hash, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<H> Debug for BuildHasherDefault<H>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for DecodeUtf16<I> where
    I: Debug + Iterator<Item = u16>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Cloned<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Copied<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Cycle<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Enumerate<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Fuse<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::__std_iter::Intersperse<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Clone,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Peekable<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Skip<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for StepBy<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::__std_iter::Take<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Combinations<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for CombinationsWithReplacement<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug,
    <I as Iterator>::Item: Clone, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::ExactlyOneError<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Intersperse<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for MultiPeek<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Permutations<I> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::PutBack<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for PutBackN<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for RcIter<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Step<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Tee<I> where
    I: Debug + Iterator,
    <I as Iterator>::Item: Debug, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::WhileSome<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Debug for Dim<I> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for FilterMap<I, F> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for Inspect<I, F> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for Map<I, F> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Batching<I, F> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Coalesce<I, F> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, F> Debug for KMergeBy<I, F> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, G> Debug for IntersperseWith<I, G> where
    I: Iterator + Debug,
    G: Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::ConsTuples<I, J> where
    I: Debug + Iterator<Item = J>,
    J: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Interleave<I, J> where
    I: Debug,
    J: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::InterleaveShortest<I, J> where
    I: Debug + Iterator,
    J: Debug + Iterator<Item = <I as Iterator>::Item>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Product<I, J> where
    I: Debug + Iterator,
    J: Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::ZipEq<I, J> where
    I: Debug,
    J: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::MergeBy<I, J, F> where
    I: Iterator + Debug,
    J: Iterator<Item = <I as Iterator>::Item> + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, J, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::MergeJoinBy<I, J, F> where
    I: Iterator + Debug,
    J: Iterator + Debug,
    <I as Iterator>::Item: Debug,
    <J as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, P> Debug for Filter<I, P> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, P> Debug for MapWhile<I, P> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, P> Debug for SkipWhile<I, P> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, P> Debug for TakeWhile<I, P> where
    I: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, Pred> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::DedupBy<I, Pred> where
    I: Iterator + Debug,
    <I as Iterator>::Item: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, St, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::__std_iter::Scan<I, St, F> where
    I: Debug,
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::TupleCombinations<I, T> where
    T: Debug + HasCombination<I>,
    I: Debug + Iterator,
    <T as HasCombination<I>>::Combination: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::TupleWindows<I, T> where
    T: Debug + HomogeneousTuple,
    I: Debug + Iterator<Item = <T as TupleCollect>::Item>, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, U> Debug for Flatten<I> where
    I: Debug + Iterator,
    U: Debug + Iterator,
    <I as Iterator>::Item: IntoIterator,
    <<I as Iterator>::Item as IntoIterator>::IntoIter == U,
    <<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item, 

pub 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, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I, V, F> Debug for UniqueBy<I, V, F> where
    V: Debug + Hash + Eq,
    I: Iterator + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::ops::Range<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for RangeFrom<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for RangeInclusive<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for RangeTo<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Idx> Debug for RangeToInclusive<Idx> where
    Idx: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<K> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_set::IntoIter<K> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K> Debug for LutImpl<K> where
    K: Debug + LutKer, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, T> Debug for ElementWiseImpl<K, T> where
    T: Debug + Copy + PartialEq<T> + Send + Sync,
    K: Debug + ElementWiseKer<T> + Clone, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, TC, TI> Debug for MatMatMulImpl<K, TC, TI> where
    K: MatMatMulKer<TI> + 'static,
    TC: Copy + Debug + 'static,
    TI: Copy + Add<TI> + Mul<TI> + Zero + Debug + 'static, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::IntoIter<K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::IntoKeys<K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_map::IntoValues<K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::IntoIter<K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::IntoKeys<K, V> where
    K: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::collections::hash_map::IntoValues<K, V> where
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V> Debug for BTreeMap<K, V> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<K, V, S> Debug for HashMap<K, V, S> where
    K: Debug,
    V: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<L, R> Debug for Either<L, R> where
    R: Debug,
    L: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<P> Debug for Pin<P> where
    P: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Parts, D> Debug for tract_pulse::internal::tract_core::ops::nn::tract_ndarray::Zip<Parts, D> where
    D: Debug,
    Parts: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for BufReader<R> where
    R: Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<R> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Bytes<R> where
    R: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Iterate<St, F> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<St, F> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Unfold<St, F> where
    St: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Bound<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Option<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TryLockError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for TrySendError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Poll<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::FoldWhile<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::MinMaxResult<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Position<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_ndarray::FoldWhile<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Arc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OutletMap<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PhantomData<T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::binary_heap::IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for IntoIterSorted<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::btree_set::IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::linked_list::IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::collections::vec_deque::IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Rc<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::rc::Weak<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Cell<T> where
    T: Copy + Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RefCell<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for UnsafeCell<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Reverse<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for BTreeSet<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for BinaryHeap<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LinkedList<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for VecDeque<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Pending<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Ready<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Cursor<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Take<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for OnceCell<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SyncOnceCell<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Discriminant<T>

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for ManuallyDrop<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Wrapping<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for AssertUnwindSafe<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for NonNull<T> where
    T: ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::result::IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for AtomicPtr<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::sync::mpsc::IntoIter<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Receiver<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SendError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Sender<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for SyncSender<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Mutex<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for PoisonError<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for RwLock<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::sync::Weak<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for JoinHandle<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for LocalKey<T> where
    T: 'static, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::thread::__FastLocalKeyInner<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::thread::__OsLocalKeyInner<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::__std_iter::Empty<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::__std_iter::Once<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for Rev<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::TupleBuffer<T> where
    T: Debug + HomogeneousTuple,
    <T as TupleCollect>::Buffer: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::Zip<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> Debug for MaybeUninit<T>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for tract_pulse::internal::tract_core::ops::nn::tract_data::internal::tract_smallvec::alloc::vec::IntoIter<T, A> where
    T: Debug,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for Box<T, A> where
    T: Debug + ?Sized,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, A> Debug for Vec<T, A> where
    T: Debug,
    A: Allocator, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, D> Debug for SliceInfo<T, D> where
    T: Debug + ?Sized,
    D: Debug + Dimension, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, E> Debug for Result<T, E> where
    T: Debug,
    E: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F> Debug for Lazy<T, F> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F> Debug for SyncLazy<T, F> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, F> Debug for Successors<T, F> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, S> Debug for HashSet<T, S> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::io::Chain<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, U> Debug for tract_pulse::internal::tract_core::ops::nn::tract_itertools::ZipLongest<T, U> where
    T: Debug,
    U: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T, const N: usize> Debug for tract_pulse::internal::tract_core::ops::nn::tract_downcast_rs::__std::array::IntoIter<T, N> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<TI> Debug for FusedKerSpec<TI> where
    TI: Debug + Copy, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for BufWriter<W> where
    W: Write + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for IntoInnerError<W> where
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<W> Debug for LineWriter<W> where
    W: Write + Debug, 

pub fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<Y, R> Debug for GeneratorState<Y, R> where
    R: Debug,
    Y: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Loading content...