Rust dbg! macro: inspect values with Debug

SOURCE-BACKED

Reference: dbg!, Debug

dbg!(expression) prints the source location, expression text, and its Debug value to stderr, then returns the evaluated value unchanged. Use it for quick inspection while debugging.

EXAMPLE: CI-CHECKEDTEST ASSERTED · examples/format-output/src/reference_examples.rs#debug-expression

let width = 6;
let area = dbg!(width * 4);
assert_eq!(area, 24);

What dbg! prints

dbg! uses the Debug representation of the value and includes the source location plus the expression text. It is active in release builds too.

Its exact text format is not a stable interface, so do not parse it or use it as application output.

dbg! returns the value

Because dbg! returns the evaluated expression, it can be inserted into an expression while you inspect an intermediate result.

For non-Copy values, calling dbg!(value) moves the value into the macro and back out. Borrow when the result is not being rebound:

EXAMPLE: CI-CHECKEDTEST ASSERTED · examples/format-output/src/reference_examples.rs#debug-borrow

let label = String::from("ready");
dbg!(&label);
assert_eq!(label, "ready");

Debug output without dbg!

Debug is the formatting trait for programmer-facing output. Use {:?} for compact output and {:#?} for the alternate, pretty representation.

EXAMPLE: CI-CHECKEDTEST ASSERTED · examples/format-output/src/reference_examples.rs#debug-formats

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

let point = Point { x: 3, y: 4 };
let compact = format!("{point:?}");
let pretty = format!("{point:#?}");

If {:?} produces E0277 because your type lacks the trait, see type doesn’t implement Debug.

Common value-printing tasks

• Print a Vec with compact or pretty Debug
• Print a struct or array and derive Debug for your own struct

Related references

• Debug vs Display for choosing the representation by audience
• Pretty Debug with {:#?} for multi-line inspection
• Formatting traits for the trait behind each format suffix

For durable application diagnostics, use a logging or tracing facility. This page covers inspection output only; it does not claim to diagnose general compiler errors.

Related Rust guides

• Debug vs Display in Rust

  Choose between Rust Debug and Display based on programmer-facing inspection versus deliberate user-facing text.

• Rust pretty print a struct with {:#?}

  Pretty print Rust structs, enums, maps, and nested values with {:#?}, derive Debug, and understand why Debug output is not a stable serialization format.

• Print structs and arrays in Rust

  Print a Rust struct by deriving Debug and using {:?} or {:#?}, and print arrays with the same Debug formatting syntax.

• Print a Vec in Rust

  Print a Rust Vec with {:?} or {:#?}, understand why {} fails, and format vector elements yourself when you need user-facing output.

• Rust E0277: type doesn't implement Debug

  Fix Rust E0277 when a value cannot be formatted with {:?} because its type does not implement std::fmt::Debug.

• Rust format strings - syntax, width, precision, and traits

  Read Rust format strings from {} through argument capture, width, precision, alignment, escaping, and formatting traits.

• Rust formatting traits - Display, Debug, hex, binary, and more

  Map Rust format syntax such as {}, {:?}, {:x}, {:b}, and {:e} to the std::fmt traits Display, Debug, LowerHex, Binary, and LowerExp.