How to Print Structs and Arrays in Rust

Rust does not automatically choose a text representation for every custom type. You will learn to print arrays with the Debug formatter, make a struct printable with #[derive(Debug)], and choose between the Debug ({:?}) and Display ({}) formatting traits.

Rust formatting is trait-based. A formatting placeholder in println! tells Rust which formatting trait the value must implement.

• {:?} uses the Debug trait. It is intended for developers: logging, inspecting values, and troubleshooting.
• {} uses the Display trait. It is intended for user-facing, readable output.

Arrays whose element types implement Debug, including [i32; 10], can be printed with {:?}. A custom struct does not implement Debug automatically because Rust requires you to explicitly opt in. For ordinary structs, #[derive(Debug)] asks the compiler to generate that implementation.

This explicit approach matters because a type's output may reveal sensitive fields, be expensive to build, or need a carefully designed user-facing format.

Think of a value as an object that can be described in different languages.

• Debug is a technician's report: it shows the structure and field values so a developer can inspect what happened.
• Display is a polished label for an end user: it shows only the information and wording you choose.

println! needs to know which description to request. {:?} requests the technician's report, while {} requests the polished label.

Use {:?} for a type that implements Debug.

#[derive(Debug)]
struct MyStruct {
    a: i32,
    b: i32,
}

fn main() {
    let item = MyStruct { a: 10, b: 20 };
    let arr: [i32; 10] = [1; 10];

    println!("Struct: {:?}", item);
    println!("Array: {:?}", arr);
}

Possible output:

Struct: MyStruct { a: 10, b: 20 }
Array: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

For multi-line debug output, use {:#?}:

println!("{:#?}", item);

This produces a more indented, readable representation for nested values.

Consider this program:

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

fn main() {
    let point = Point { x: 3, y: 7 };
    let values = [4, 8, 15];

    println!("point = {:?}", point);
    println!("values = {:?}", values);
}

1. #[derive(Debug)] generates an implementation of Debug for Point.
2. point is created with x equal to 3 and y equal to 7.
3. values is an array of three i32 values. i32 implements Debug, so the array can also implement Debug.
4. The first println! sees {:?} and calls Debug formatting for point.
5. The second println! calls Debug formatting for the array.

Output:

point = Point { x: 3, y: 7 }
values = [4, 8, 15]

• Debugging API data: Print a deserialized response struct while developing an HTTP client.
• Inspecting configuration: Log an array of enabled ports or feature flags.
• Testing: Include {:?} in assertion messages so failed tests show the actual value.
• Command-line tools: Use Display for normal output and Debug when a --verbose option is enabled.
• Data processing: Inspect batches of parsed values before writing them to a database or file.

In production Rust code, developers usually derive Debug broadly on application data types because it helps with diagnostics and test failures.

#[derive(Debug, Clone, PartialEq)]
struct User {
    id: u64,
    name: String,
}

Common patterns include:

• Logging values during failures:

  eprintln!("Could not process request: {:?}", request);
  

• Using Debug in assertions:

  assert_eq!(actual, expected, "actual value: {:?}", actual);
  

• Implementing Display for user-facing errors:

  use std::fmt;
  
  struct InvalidAge;
  
  impl fmt::Display for InvalidAge {
      fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
          write!(f, "age must be at least 18")
      }
  }
  

Be deliberate with sensitive data. A derived Debug output can include passwords, tokens, and personal data if those fields are present. Avoid logging such values or implement a custom Debug formatter that redacts them.

Using {} when only Debug is available

This does not compile because deriving Debug does not implement Display:

#[derive(Debug)]
struct MyStruct {
    a: i32,
    b: i32,
}

let value = MyStruct { a: 1, b: 2 };
println!("{}", value); // Error: Display is not implemented

Use {:?} for debug output, or implement Display when you need {}.

Forgetting #[derive(Debug)]

struct MyStruct {
    a: i32,
    b: i32,
}

let value = MyStruct { a: 1, b: 2 };
println!("{:?}", value); // Error: Debug is not implemented

Add #[derive(Debug)] above the struct definition.

Printing an array with a non-debug element type

An array can be debug-printed only when its elements can be debug-printed. If a custom element type lacks Debug, deriving Debug for that element type is usually the fix.

Treating Debug as a stable file or API format

Debug output is for developers. Do not parse it or rely on its exact text for saved data, network protocols, or tests that require a stable format.

Logging secrets accidentally

#[derive(Debug)] prints all printable fields by default. Do not debug-print authentication tokens, passwords, or private keys in logs.

Debug is usually the best first choice for printing structs during development. Choose Display when the wording, layout, or included fields must be intentional.

use std::fmt;

struct Temperature(f64);

impl fmt::Display for Temperature {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:.1} °C", self.0)
    }
}

fn main() {
    let temp = Temperature(21.75);
    println!("{}", temp);
}

This prints 21.8 °C, rather than a developer-oriented struct representation.

// Print an array with Debug
let arr = [1, 2, 3];
println!("{:?}", arr);

// Allow a custom struct to use Debug
#[derive(Debug)]
struct User {
    id: u32,
}

let user = User { id: 42 };
println!("{:?}", user);

// Pretty, multi-line Debug output
println!("{:#?}", user);

• Use {:?} when the type implements std::fmt::Debug.
• Add #[derive(Debug)] to most simple structs and enums.
• Use {} only when the type implements std::fmt::Display.
• Debug is for developers; do not use it as a stable serialization format.
• Arrays can be formatted when their element type supports the requested formatting trait.

Why can I print an array with {:?} in Rust?

Rust arrays implement Debug when their element type implements Debug. Since i32 implements Debug, [i32; 10] does too.

Why does println!("{}", my_struct) fail?

{} requires the Display trait. Custom structs do not get Display automatically, and #[derive(Debug)] only provides Debug for {:?}.

How do I make a Rust struct printable?

For developer output, add #[derive(Debug)] and print it with {:?}. For user-facing output, implement std::fmt::Display.

Can I use both Debug and Display on one struct?

Yes. Derive or implement Debug, then implement Display separately when you need custom user-facing text.

What is the difference between {:?} and {:#?}?

Both use Debug. {:#?} requests alternate, usually multi-line and indented, debug output.

Should I derive Debug for every struct?

It is common and useful for many application types. Review types containing secrets or sensitive data before deriving it, because debug output can expose fields in logs.

Can I print only selected struct fields?

Yes. Print fields directly:

println!("a = {}, b = {}", value.a, value.b);

Or implement Display for a reusable custom format.

• Rust formatting macros — Learn how println!, format!, and write! use format strings.
• The Debug trait — Understand developer-oriented representations and #[derive(Debug)].
• The Display trait — Create intentional, user-facing text for custom types.
• Trait derivation — Generate common trait implementations such as Clone, PartialEq, and Debug.
• Structs in Rust — Define named fields and create instances of custom data types.
• Arrays and slices in Rust — Work with fixed-size arrays and borrowed sequences of values.
• Error handling in Rust — Use Display for readable errors and Debug for diagnostic detail.