Debug vs Display trait in Rust — How to Rust

In Rust, both Debug and Display are traits that control how objects are formatted and printed. However, they serve different purposes and are used in different contexts.

Debug Trait

• Purpose: The Debug trait is used to format text for debugging purposes. It provides a way to inspect the value of a type, typically in a format that is meaningful for developers.
• Usage: It is usually derived automatically using #[derive(Debug)] on types. This auto-derivation includes all the fields of the type and prints them in a way that's useful for debugging.
• Output Format: The output is typically verbose and not intended to be user-friendly. It often includes the struct’s name and all its fields with their values.

Example:

#[derive(Debug)]
struct Account {
  balance: u64,
}

let account = Account { balance: 10u64 };
// {:?} is for a Debug trait
println!("{:?}", account); // "Account { balance: 10}"

Display Trait

• Purpose: The Display trait is intended for user-facing output, where readability and conciseness are important. It is meant to be used when the formatting output should be clean and friendly to end-users.
• Usage: Unlike Debug, Display must be manually implemented, giving the developer control over what is shown.
• Output Format: The format is generally cleaner and more tailored for end users, excluding extraneous details like the struct’s name or field names unless explicitly included in the format.
• Example:

use std::fmt;

struct Account {
  balance: u64,
}

impl fmt::Display for Account {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Your balance is: {}", self.balance)
    }
}

let account = Account { balance: 10u64 };
// {} is for a Display trait
println!("{}", account); // "Your balance is: 10"

Key Differences

• Derivation: Debug can be derived automatically, while Display requires a manual implementation.
• Intended Audience: Debug is for developers during the debugging process, whereas Display is for the end users of the application.
• Output Detail: Debug generally provides more detailed and technical output, while Display aims for readability and simplicity.

Developers should use Debug for internal logs and during development, while Display should be used for output that is intended to be read by users of the application.