Formatting

We’ve seen that formatting is specified via a format string:

  • format!("{}", foo) -> "3735928559"
  • format!("0x{:X}", foo) ->
    "0xDEADBEEF"
  • format!("0o{:o}", foo) -> "0o33653337357"

The same variable (foo) can be formatted differently depending on which
argument type is used: X vs o vs unspecified.

This formatting functionality is implemented via traits, and there is one trait
for each argument type. The most common formatting trait is Display, which
handles cases where the argument type is left unspecified: {} for instance.

  1. use std::fmt::{self, Formatter, Display};
  3. struct City {
  4.     name: &'static str,
  5.     // Latitude
  6.     lat: f32,
  7.     // Longitude
  8.     lon: f32,
  9. }
  11. impl Display for City {
  12.     // `f` is a buffer, this method must write the formatted string into it
  13.     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  14.         let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' };
  15.         let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' };
  17.         // `write!` is like `format!`, but it will write the formatted string
  18.         // into a buffer (the first argument)
  19.         write!(f, "{}: {:.3}°{} {:.3}°{}",
  20.                self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)
  21.     }
  22. }
  24. #[derive(Debug)]
  25. struct Color {
  26.     red: u8,
  27.     green: u8,
  28.     blue: u8,
  29. }
  31. fn main() {
  32.     for city in [
  33.         City { name: "Dublin", lat: 53.347778, lon: -6.259722 },
  34.         City { name: "Oslo", lat: 59.95, lon: 10.75 },
  35.         City { name: "Vancouver", lat: 49.25, lon: -123.1 },
  36.     ].iter() {
  37.         println!("{}", *city);
  38.     }
  39.     for color in [
  40.         Color { red: 128, green: 255, blue: 90 },
  41.         Color { red: 0, green: 3, blue: 254 },
  42.         Color { red: 0, green: 0, blue: 0 },
  43.     ].iter() {
  44.         // Switch this to use {} once you've added an implementation
  45.         // for fmt::Display
  46.         println!("{:?}", *color);
  47.     }
  48. }

You can view a full list of formatting traits and their argument
types in the std::fmt documentation.

Activity

Add an implementation of the fmt::Display trait for the Color struct above
so that the output displays as:

  1. RGB (128, 255, 90) 0x80FF5A
  2. RGB (0, 3, 254) 0x0003FE
  3. RGB (0, 0, 0) 0x000000

Two hints if you get stuck:

See also

std::fmt