let v2 = vec![1; 10];
println!("{:?}", v2);

{} is for strings and other values which can be displayed directly to the user. There’s no single way to show a vector to a user.

The {:?} formatter can be used to debug it, and it will look like:

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Display is the trait that provides the method behind {}, and Debug is for {:?}

Does anyone implement this trait for Vec<T> ?

No.

And surprisingly, this is a demonstrably correct answer; which is rare since proving the absence of things is usually hard or impossible. So how can we be so certain?

Rust has very strict coherence rules, the impl Trait for Struct can only be done:

• either in the same crate as Trait
• or in the same crate as Struct

and nowhere else; let’s try it:

impl<T> std::fmt::Display for Vec<T> {
    fn fmt(&self, _: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        Ok(())
    }
}

yields:

error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
 --> src/main.rs:1:1
  |
1 | impl<T> std::fmt::Display for Vec<T> {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type parameter `T` must be used as the type parameter for some local type
  |
  = note: only traits defined in the current crate can be implemented for a type parameter

Furthermore, to use a trait, it needs to be in scope (and therefore, you need to be linked to its crate), which means that:

• you are linked both with the crate of Display and the crate of Vec
• neither implement Display for Vec

and therefore leads us to conclude that no one implements Display for Vec.

As a work around, as indicated by Manishearth, you can use the Debug trait, which is invokable via "{:?}" as a format specifier.

If you know the type of the elements that the vector contains, you could make a struct that takes vector as an argument and implement Display for that struct.

use std::fmt::{Display, Formatter, Error};

struct NumVec(Vec<u32>);

impl Display for NumVec {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        let mut comma_separated = String::new();

        for num in &self.0[0..self.0.len() - 1] {
            comma_separated.push_str(&num.to_string());
            comma_separated.push_str(", ");
        }

        comma_separated.push_str(&self.0[self.0.len() - 1].to_string());
        write!(f, "{}", comma_separated)
    }
}

fn main() {
    let numbers = NumVec(vec![1; 10]);
    println!("{}", numbers);
}

Here is a one-liner which should also work for you:

println!("[{}]", v2.iter().fold(String::new(), |acc, &num| acc + &num.to_string() + ", "));

Here is
a runnable example.

In my own case, I was receiving a Vec<&str> from a function call. I did not want to change the function signature to a custom type (for which I could implement the Display trait).

For my one-of case, I was able to turn the display of my Vec into a one-liner which I used with println!() directly as follows:

println!("{}", myStrVec.iter().fold(String::new(), |acc, &arg| acc + arg));

(The lambda can be adapted for use with different data types, or for more concise Display trait implementations.)

Starting with Rust 1.58, there is a slightly more concise way to print a vector (or any other variable). This lets you put the variable you want to print inside the curly braces, instead of needing to put it at the end. For the debug formatting needed to print a vector, you add :? in the braces, like this:

fn main() {
    let v2 = vec![1; 10];
    println!("{v2:?}");
}

Sometimes you don’t want to use something like the accepted answer

let v2 = vec![1; 10];
println!("{:?}", v2);

because you want each element to be displayed using its Display trait, not its Debug trait; however, as noted, you can’t implement Display on Vec because of Rust’s coherence rules. Instead of implementing a wrapper struct with the Display trait, you can implement a more general solution with a function like this:

use std::fmt;

pub fn iterable_to_str<I, D>(iterable: I) -> String
where
    I: IntoIterator<Item = D>,
    D: fmt::Display,
{
    let mut iterator = iterable.into_iter();

    let head = match iterator.next() {
        None => return String::from("[]"),
        Some(x) => format!("[{}", x),
    };
    let body = iterator.fold(head, |a, v| format!("{}, {}", a, v));
    format!("{}]", body)
}

which doesn’t require wrapping your vector in a struct. As long as it implements IntoIterator and the element type implements Display, you can then call:

println!("{}", iterable_to_str(it));

another one liner using version 1.77.2 :

println!("{}", Vec::from_iter(v2.iter().map(|i| i.to_string())).join(", "));

Is there any reason not to write the vector’s content item by item w/o former collecting? *)
Meanwhile rust allows variables inside format strings. The program has been updated according to cafce25 ‘s suggestions for improvement:

use std::fmt::{Display, Formatter, Error};

struct NumVec(Vec<u32>);

impl Display for NumVec {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        let v = &self.0;
        if v.is_empty() {
            return Ok(());
        }
        for num in &v[0..v.len() - 1] {
            write!(f, "{num}, ")?
        }
        write!(f, "{}", &v[v.len() - 1])
    }
}

fn main() {
    let numbers = NumVec(vec![1; 10]);
    println!("{}", numbers);
}

*) No there isn’t.

Because we want to display something, the Display trait is implemented for sure. So this is correct Rust because: the Doc says about the ToString trait:

“This trait is automatically implemented for any type which implements the Display trait. As such, ToString shouldn’t be implemented directly: Display should be implemented instead, and you get the ToString implementation for free.”

In particular on microcontrollers where space is limited I definitely would go with this solution and write immediately.

Playground