Struct DebugTuple

pub struct DebugTuple<'f, 'w> { /* private fields */ }

For debug formatting a tuple struct, or tuple variant.

Example

This example demonstrates how you can debug format a tuple struct, and an enum of tuple variants.

use const_format::{Error, Formatter};
use const_format::{call_debug_fmt, coerce_to_fmt, formatc, impl_fmt, try_};

fn main() {
    const STRUC: &str = formatc!("{:?}", Foo(5, [8, 13, 21], "34"));
    const ENUM_: &str = formatc!("{:?}", Bar::Baz(false, None));
     
    assert_eq!(STRUC, "Foo(5, [8, 13, 21], \"34\")");
    assert_eq!(ENUM_, "Baz(false, None)");
}

struct Foo(u32, [u32; 3], &'static str);

enum Bar {
    Baz(bool, Option<bool>),
}

impl_fmt!{
    impl Foo;
     
    const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let mut f = f.debug_tuple("Foo");
        try_!(coerce_to_fmt!(&self.0).const_debug_fmt(f.field()));
        try_!(coerce_to_fmt!(&self.1).const_debug_fmt(f.field()));
        try_!(coerce_to_fmt!(&self.2).const_debug_fmt(f.field()));
        f.finish()
    }
}

impl_fmt!{
    impl Bar;
     
    const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        match self {
            Bar::Baz(f0, f1) => {
                let mut f = f.debug_tuple("Baz");
                 
                // This macro allows debug formatting some generic types that
                // don't have a const_debug_fmt fn, like Options which wrap non-std types.
                call_debug_fmt!(std, f0, f.field());
                call_debug_fmt!(Option, f1, f.field());
                 
                f.finish()
            }
        }
    }
}

Implementations

impl<'f, 'w> DebugTuple<'f, 'w>

pub const fn field(&mut self) -> &mut Formatter<'w>

Adds a field to the formatted output.

pub const fn finish(self) -> Result<(), Error>

Finishes writing the tuple struct/variant, and if anything went wrong in the field method,returns an error.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes