Struct `DebugTuple`

struct DebugTuple<'a, 'b: 'a> { ... }

A struct to help with fmt::Debug implementations.

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

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

Examples

use std::fmt;

struct Foo(i32, String);

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_tuple("Foo")
           .field(&self.0)
           .field(&self.1)
           .finish()
    }
}

assert_eq!(
    format!("{:?}", Foo(10, "Hello World".to_string())),
    r#"Foo(10, "Hello World")"#,
);

Implementations

`impl<'a, 'b: 'a> DebugTuple<'a, 'b>`

fn field(self: &mut Self, value: &dyn Debug) -> &mut Self

Adds a new field to the generated tuple struct output.

Examples

use std::fmt;

struct Foo(i32, String);

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_tuple("Foo")
           .field(&self.0) // We add the first field.
           .field(&self.1) // We add the second field.
           .finish() // We're good to go!
    }
}

assert_eq!(
    format!("{:?}", Foo(10, "Hello World".to_string())),
    r#"Foo(10, "Hello World")"#,
);

fn field_with<F>(self: &mut Self, value_fmt: F) -> &mut Self where F: FnOnce(&mut Formatter<'_>) -> Result

Adds a new field to the generated tuple struct output.

This method is equivalent to DebugTuple::field, but formats the value using a provided closure rather than by calling Debug::fmt.

fn finish_non_exhaustive(self: &mut Self) -> Result

Marks the tuple 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 Foo(i32, String);

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

assert_eq!(
    format!("{:?}", Foo(10, "secret!".to_owned())),
    "Foo(10, ..)",
);

fn finish(self: &mut Self) -> Result

Finishes output and returns any error encountered.

Examples

use std::fmt;

struct Foo(i32, String);

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_tuple("Foo")
           .field(&self.0)
           .field(&self.1)
           .finish() // You need to call it to "finish" the
                     // tuple formatting.
    }
}

assert_eq!(
    format!("{:?}", Foo(10, "Hello World".to_string())),
    r#"Foo(10, "Hello World")"#,
);

`impl<'a, 'b> Freeze for DebugTuple<'a, 'b>`

`impl<'a, 'b> RefUnwindSafe for DebugTuple<'a, 'b>`

`impl<'a, 'b> Send for DebugTuple<'a, 'b>`

`impl<'a, 'b> Sync for DebugTuple<'a, 'b>`

`impl<'a, 'b> Unpin for DebugTuple<'a, 'b>`

`impl<'a, 'b> UnsafeUnpin for DebugTuple<'a, 'b>`

`impl<'a, 'b> UnwindSafe for DebugTuple<'a, 'b>`

`impl<T> Any for DebugTuple<'a, 'b>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for DebugTuple<'a, 'b>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for DebugTuple<'a, 'b>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for DebugTuple<'a, 'b>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for DebugTuple<'a, 'b>`

fn into(self: Self) -> U

Calls U::from(self).

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

`impl<T, U> TryFrom for DebugTuple<'a, 'b>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for DebugTuple<'a, 'b>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>