Crate fmt_derive

More robust and versatile implementation of derive(Debug) and derive(Display). Unlike the version of derive(Debug) in the standard library, these macros will always successfully generate an implementation - even if a member does not implement Debug/Display. In that case, the generated implementation will print a replacement string of the form <TypeName>.

More Robust

These derive macros always work, even when derive(std::fmt::Debug) fails.

// a type that implements neither `Debug` nor `Display`
struct Unprintable;

#[derive(fmt_derive::Debug, fmt_derive::Display)]
struct Printable(Unprintable);

fn main() {
  // error[E0277]: `Unprintable` doesn't implement `Debug`
  // println!("{:?}", Unprintable);

  assert_eq!(format!("{:?}", Printable(Unprintable)), "Printable(<Unprintable>)");

  // deriving display is often more useful with a custom format expression, but will silently fall back to the same
  // behavior as `Debug`
  assert_eq!(format!("{}", Printable(Unprintable)), "Printable(<Unprintable>)");
}

Drop in Usage

Anything that derives [std::fmt::Debug] or core::fmt::Debug can derive fmt_derive::Debug instead without any changes required.

However, both cannot be used at the same time, as their names clash:

// error[E0252]: the name `Debug` is defined multiple times
use fmt_derive::Debug;
use core::fmt::Debug;

The same problem exists for Display:

// error[E0252]: the name `Display` is defined multiple times
use fmt_derive::Display;
use core::fmt::Display;

If you encounter this problem, there is a simple solution: use fmt_derive::Debug; also pulls in the [std::fmt::Debug]/core::fmt::Debug trait, there is no need to use the standard library Debug.

use fmt_derive::Debug; // replace `use std::fmt::Debug;` and `use core::fmt::Debug;`

struct Unprintable;

#[derive(Debug)]
struct Printable(Unprintable);

fn main() {
  // error[E0277]: `Unprintable` doesn't implement `Debug`
  // println!("{:?}", Unprintable);

  assert_eq!(format!("{:?}", &Printable(Unprintable) as &dyn Debug), "Printable(<Unprintable>)");
}

More Versatile

The derived implementation can be easily customized using additional attributes.

Custom Format Expressions

A custom representation can be quickly derived using a format expression for the whole structure, enumeration, or untagged unions. This is the expected case when deriving Display or when a member needs to be formatted in a special manner:

use fmt_derive::{Debug, Display};

#[derive(Display, Debug)]
#[debug("T<0x{:X}>", self.0)]
#[display("A thing that sits on the number {}", self.0)]
struct Thing(u32);

fn main() {
  assert_eq!(format!("{:?}", Thing(0xF7A)), "T<0xF7A>");
  assert_eq!(format!("{}", Thing(42)), "A thing that sits on the number 42");
}

Custom Format Expressions for Enumeration Variants

For enumerations, variants can also be customized:

use fmt_derive::Debug;

#[derive(Debug)]
enum Thing{
  // tuple members are exposed as `_0`, `_1`, and so forth
  #[debug("Thing::VariantA(0x{:X}, {})", _0, _1)]
  VariantA(u32, u32),
  // struct members are exposed under their name
  #[debug("Thing::VariantB({})", x)]
  VariantB{
    x: u32,
    unused: u32,
  }
}

fn main() {
  assert_eq!(format!("{:?}", Thing::VariantA(0xF7A, 42)), "Thing::VariantA(0xF7A, 42)");
  assert_eq!(format!("{:?}", Thing::VariantB{x: 42, unused: 0}), "Thing::VariantB(42)");
}

Custom Format Expressions for Individual Fields

Or by customizing an individual field:

use fmt_derive::Debug;

#[derive(Debug)]
struct Thing(#[debug("0x{:X}", self.0)] u32);

fn main() {
  assert_eq!(format!("{:?}", Thing(0xF7A)), "Thing(0xF7A)");
}

Ignoring a Field

Although it is possible to derive a debug message for any field, it is sometimes preferable to not print a field at all:

use fmt_derive::Debug;

#[derive(Debug)]
struct Function(#[debug(ignore)] fn());

fn main() {
  assert_eq!(format!("{:?}", Function(main)), "Function");
}

Traits

• Debug
  The trait and macro from the standard library. Only the trait is actually exposed by this crate. ? formatting.
• Display
  The trait and macro from the standard library. Only the trait is actually exposed by this crate. Format trait for an empty format, {}.

Derive Macros

• Debug
  Derive implementations of Debug for arbitrary structs and enums (unions are supported only with a top-level format directive). useing fmt_derive::Debug, will also pull in the core::fmt::Debug/[std::fmt::Debug] trait (but the macro of the same name will be replaced with this one).
• Debug
  The trait and macro from the standard library. Only the trait is actually exposed by this crate. Derive macro generating an impl of the trait Debug.
• Display
  Derive implementations of Display for arbitrary structs and enums (unions are supported only with a top-level format directive).. useing fmt_derive::Display, will also pull in the core::fmt::Display/[std::fmt::Display] trait (but the macro of the same name will be replaced with this one).