#derive #macro-derive #customizable

macro derive-debug

Customizable derive macro for Debug trait

3 releases

0.1.2 Jan 20, 2023
0.1.1 Jan 20, 2023
0.1.0 Jan 18, 2023

#553 in Debugging

Download history 2079/week @ 2024-06-28 2429/week @ 2024-07-05 2505/week @ 2024-07-12 1844/week @ 2024-07-19 3133/week @ 2024-07-26 2954/week @ 2024-08-02 2976/week @ 2024-08-09 2537/week @ 2024-08-16 3194/week @ 2024-08-23 3322/week @ 2024-08-30 3674/week @ 2024-09-06 3260/week @ 2024-09-13 3579/week @ 2024-09-20 3869/week @ 2024-09-27 3264/week @ 2024-10-04 2476/week @ 2024-10-11

13,690 downloads per month
Used in 9 crates (4 directly)

MIT license

19KB
342 lines

derive-debug

This crate implements a more customizable version of #[derive(Debug)].

Usage

The usage is very similar to #[derive(Debug)] with a few extra customization options.

Deriving a struct

use derive_debug::Dbg;

#[derive(Dbg)]
struct Foo {
    field_a: u32,
    #[dbg(placeholder = "...")]
    field_b: Vec<u32>, // will be printed as "field_b: ..."
    #[dbg(skip)]
    field_c: bool, // will be left out
    #[dbg(alias = "my_string")]
    field_d: u32, // will be printed as "my_string: 42"
    #[dbg(fmt = "{:#06X}")]
    field_e: u32, // will be printed with the specified format
}

Deriving an enum

use derive_debug::Dbg;

#[derive(Dbg)]
enum Foo {
    VariantA(u32, u32, u32),
    #[dbg(skip)]
    VariantB{a: u32, b: bool}, // Will be printed as "VariantB"

    // same options available as for struct fields
    VariantC{a: u32, #[dbg(placeholder = "...")] b: bool}
}

Detailed options

Field Options

  • #[dbg(skip)] completely omits a field in the output
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo {
        field_a: bool,
        #[dbg(skip)]
        field_b: u32,
    }

    // Outputs: Foo { field_a: true }
  • #[dbg(placeholder = "xyz")] will print xyz instead of the actual contents of a field
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo {
        field_a: bool,
        #[dbg(placeholder = "...")]
        field_b: u32,
    }

    // Outputs: Foo { field_a: true, field_b: ... }
  • #[dbg(alias = "some_alias")] will print some_alias as field name instead of the real name
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo {
        field_a: bool,
        #[dbg(alias="not_field_b")]
        field_b: u32,
    }

    // Outputs: Foo { field_a: true, not_field_b: 42 }
  • #[dbg(fmt = "{:#06X}")] will print the field with the specified format
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo {
        field_a: bool,
        #[dbg(fmt = "{:#06X}")]
        field_b: u32,
    }

    // Outputs: Foo { field_a: true, field_b: 0x002A }
  • #[dbg(formatter = "my_func")] will print the field using the specified function.
    The function has to return a type that can be formatted using "{}"
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo(u32, #[dbg(formatter = "fmt_not_zero")] u32);

    fn fmt_not_zero(v: &u32) -> &'static str {
        if *v == 0 {
            "0"
        } else {
            "not 0"
        }
    }

    // Outputs: Foo(42, not 0)

Enum Variant Options

  • #[dbg(skip)] only prints the name of the variant and omits its contents
    use derive_debug::Dbg;

    #[derive(Dbg)]
    enum Foo {
        #[dbg(skip)]
        SomeVariant{a: bool, b: u32},
    }

    // Outputs: SomeVariant
  • #[dbg(alias = "some_alias")] will use some_alias as variant name instead of the real name
    use derive_debug::Dbg;

    #[derive(Dbg)]
    enum Foo {
        #[dbg(alias = "NotSomeVariant")]
        SomeVariant{a: bool, b: u32},
    }

    // Outputs: NotSomeVariant { a: true, b: 42 }

struct Options

  • #[dbg(alias = "MyAlias")] will use MyAlias as struct name instead of the real name
    use derive_debug::Dbg;

    #[derive(Dbg)]
    #[dbg(alias = "NotFoo")]
    struct Foo {
        field_a: bool,
        field_b: u32,
    }

    // Outputs: NotFoo { field_a: true, not_field_b: 42 }

Dependencies

~1.5MB
~36K SLoC