Testcase: List

Implementing fmt::Display for a structure where the elements must each be
handled sequentially is tricky. The problem is that each write! generates a
fmt::Result. Proper handling of this requires dealing with all the
results. Rust provides the ? operator for exactly this purpose.

Using ? on write! looks like this:

  1. // Try `write!` to see if it errors. If it errors, return
  2. // the error. Otherwise continue.
  3. write!(f, "{}", value)?;

Alternatively, you can also use the try! macro, which works the same way.
This is a bit more verbose and no longer recommended, but you may still see it in
older Rust code. Using try! looks like this:

  1. try!(write!(f, "{}", value));

With ? available, implementing fmt::Display for a Vec is
straightforward:

  1. use std::fmt; // Import the `fmt` module.
  3. // Define a structure named `List` containing a `Vec`.
  4. struct List(Vec<i32>);
  6. impl fmt::Display for List {
  7.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  8.         // Extract the value using tuple indexing
  9.         // and create a reference to `vec`.
  10.         let vec = &self.0;
  12.         write!(f, "[")?;
  14.         // Iterate over `vec` in `v` while enumerating the iteration
  15.         // count in `count`.
  16.         for (count, v) in vec.iter().enumerate() {
  17.             // For every element except the first, add a comma.
  18.             // Use the ? operator, or try!, to return on errors.
  19.             if count != 0 { write!(f, ", ")?; }
  20.             write!(f, "{}", v)?;
  21.         }
  23.         // Close the opened bracket and return a fmt::Result value
  24.         write!(f, "]")
  25.     }
  26. }
  28. fn main() {
  29.     let v = List(vec![1, 2, 3]);
  30.     println!("{}", v);
  31. }

Activity

Try changing the program so that the index of each element in the vector is also printed. The new output should look like this:

  1. [0: 1, 1: 2, 2: 3]

See also

for, ref, Result, struct,
?, and vec!