pub struct DebugStruct<'a, 'b> where
    'b: 'a, 
{ /* private fields */ }
Expand description

A struct to help with fmt::Debug implementations.

This is useful when you wish to output a formatted struct as a part of your Debug::fmt implementation.

This can be constructed by the Formatter::debug_struct method.

Examples

use std::fmt;

struct Foo {
    bar: i32,
    baz: String,
}

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("Foo")
           .field("bar", &self.bar)
           .field("baz", &self.baz)
           .finish()
    }
}

assert_eq!(
    format!("{:?}", Foo { bar: 10, baz: "Hello World".to_string() }),
    "Foo { bar: 10, baz: \"Hello World\" }",
);

Implementations

Adds a new field to the generated struct output.

Examples
use std::fmt;

struct Bar {
    bar: i32,
    another: String,
}

impl fmt::Debug for Bar {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("Bar")
           .field("bar", &self.bar) // We add `bar` field.
           .field("another", &self.another) // We add `another` field.
           // We even add a field which doesn't exist (because why not?).
           .field("not_existing_field", &1)
           .finish() // We're good to go!
    }
}

assert_eq!(
    format!("{:?}", Bar { bar: 10, another: "Hello World".to_string() }),
    "Bar { bar: 10, another: \"Hello World\", not_existing_field: 1 }",
);

Marks the struct as non-exhaustive, indicating to the reader that there are some other fields that are not shown in the debug representation.

Examples
use std::fmt;

struct Bar {
    bar: i32,
    hidden: f32,
}

impl fmt::Debug for Bar {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("Bar")
           .field("bar", &self.bar)
           .finish_non_exhaustive() // Show that some other field(s) exist.
    }
}

assert_eq!(
    format!("{:?}", Bar { bar: 10, hidden: 1.0 }),
    "Bar { bar: 10, .. }",
);

Finishes output and returns any error encountered.

Examples
use std::fmt;

struct Bar {
    bar: i32,
    baz: String,
}

impl fmt::Debug for Bar {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("Bar")
           .field("bar", &self.bar)
           .field("baz", &self.baz)
           .finish() // You need to call it to "finish" the
                     // struct formatting.
    }
}

assert_eq!(
    format!("{:?}", Bar { bar: 10, baz: "Hello World".to_string() }),
    "Bar { bar: 10, baz: \"Hello World\" }",
);

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.