How to Print a Vec in Rust: Display vs Debug

By the end of this page, you will understand why Vec<T> cannot be printed with {} in Rust, when to use {:?} instead, and how Display differs from Debug. You will also learn practical ways to print vectors, including pretty-printing and creating custom output when you want a human-friendly format.

Rust has two common formatting traits for printing values:

• Display → for user-facing, clean output with {}
• Debug → for developer-facing output with {:?}

A Vec<T> implements Debug, but not Display.

That means this works:

let v = vec![1, 2, 3];
println!("{:?}", v);

But this does not:

let v = vec![1, 2, 3];
println!("{}", v); // error

Why Vec<T> does not implement Display

Think of Display and Debug as two different labels on a printer:

• Display = show this nicely to a user
• Debug = show this clearly to a programmer

A Vec<T> is like a box full of items. If someone says, "print the box nicely," Rust asks: what does nicely mean?

• As a comma-separated list?
• As JSON-like text?
• As a vertical list?

There is no single best answer, so Rust refuses to guess for Display.

But for debugging, a standard inspected form is fine, so Debug prints the contents in a consistent developer-friendly way.

The most important syntax is:

println!("{:?}", value);   // Debug
println!("{:#?}", value);  // Pretty Debug
println!("{}", value);     // Display

Printing a vector with Debug

fn main() {
    let v = vec![1, 2, 3];
    println!("{:?}", v);
}

Output:

[1, 2, 3]

Pretty-printing a vector

fn main() {
    let v = vec![1, 2, 3];
    println!("{:#?}", v);
}

Output:

Consider this example:

fn main() {
    let v = vec![1, 2, 3];
    println!("{:?}", v);
}

Step by step

1. vec![1, 2, 3] creates a Vec<i32>.
2. println! sees the format string "{:?}".
3. {:?} tells Rust: use the Debug trait.
4. Vec<i32> implements Debug, so formatting succeeds.
5. Rust prints the vector in debug form: [1, 2, 3].

Now compare it with this failing version:

fn main() {
    let v = vec![1, 2, 3];
    (, v);
}

Printing vectors appears in many practical Rust tasks:

Logging intermediate data

When debugging APIs, parsers, or algorithms, developers often inspect vectors:

println!("Parsed tokens: {:?}", tokens);

Inspecting query or processing results

A function may return a list of records, IDs, or errors:

println!("Matching IDs: {:?}", ids);

Pretty-printing nested data during development

When vectors contain structs or nested collections, {:#?} is easier to read:

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

Building user-facing output

If you are printing data for users, you usually do not rely on Debug. Instead, you format the output explicitly:

let names = vec!["Alice", "Bob", "Cara"];
println!("Users: {}", names.join());

In real Rust codebases, developers usually follow these patterns:

Use Debug for quick inspection

During development, Vec<T> is often printed with {:?} in:

• temporary debugging statements
• tests
• logs
• prototypes

dbg!(&items);
println!("Loaded items: {:?}", items);

Format user output explicitly

For command-line tools or messages shown to users, teams usually choose a deliberate format:

let output = values
    .iter()
    .map(|v| v.to_string())
    .collect::<Vec<_>>()
    .join(", ");

println!("Values: {}", output);

Use wrapper types for reusable formatting

If the same vector formatting is needed in many places, a wrapper type is common:

struct CsvVec<T>(Vec<T>);

Then can be implemented once and reused.

Mistake 1: Using {} for a vector

Broken code:

fn main() {
    let v = vec![1, 2, 3];
    println!("{}", v);
}

Why it fails:

• {} requires Display
• Vec<T> does not implement Display

Fix:

println!("{:?}", v);

Mistake 2: Assuming Debug is good for user-facing output

This works:

println!("{:?}", vec!["Alice", "Bob"]);

But the output may not be the style you want for end users.

Better:

• println!("{}", value) uses Display
• println!("{:?}", value) uses Debug
• println!("{:#?}", value) uses pretty Debug
• Vec<T> implements Debug
• Vec<T> does not implement Display
• You cannot implement Display for Vec<T> directly because of Rust's orphan rules
• For custom vector output:
  • format elements manually
  • or create a wrapper type and implement Display

Common patterns

let v = vec![1, 2, 3];
println!("{:?}", v);
println!("{:#?}", v);

Why can't I print a Vec with {} in Rust?

Because {} requires the Display trait, and Vec<T> does not implement Display.

How do I print a vector in Rust?

Use {:?} for debug output:

println!("{:?}", my_vec);

What is the difference between Display and Debug in Rust?

Display is for clean user-facing output. Debug is for programmer-facing inspection.

Can I implement Display for Vec<T> myself?

No, not directly. Rust's orphan rules prevent implementing a foreign trait for a foreign type. Use a wrapper type instead.

What does {:#?} do in Rust?

It pretty-prints Debug output across multiple lines, which is useful for complex or nested data.

• Debug trait — directly related because Vec<T> uses {:?} for printing.
• Display trait — important for understanding why {} fails.
• Formatting macros — println!, format!, and write! all use formatting traits.
• Traits — Display and Debug are traits, so this topic depends on trait behavior.
• Orphan rules — explains why you cannot implement Display for Vec<T> directly.
• Slices — often used instead of Vec<T> in functions that only need to read data.
• Iterator methods — useful for converting vector elements into custom printable strings.
• Newtype pattern — the common way to wrap Vec<T> and implement custom .