Rust by Example

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:

// Try `write!` to see if it errors. If it errors, return

// the error. Otherwise continue.

write!(f, "{}", value)?;

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

use std::fmt; // Import the `fmt` module.

// Define a structure named `List` containing a `Vec`.

struct List(Vec);

impl fmt::Display for List {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

// Extract the value using tuple indexing,

// and create a reference to `vec`.

let vec = &self.0

write!(f, "[")?;

// Iterate over `v` in `vec` while enumerating the iteration

// count in `count`.

for (count, v) in vec.iter().enumerate() {

// For every element except the first, add a comma.

// Use the ? operator to return on errors.

if count != 0 { write!(f, ", ")?; }

write!(f, "{}", v)?;

}

// Close the opened bracket and return a fmt::Result value.

write!(f, "]")

}

}

fn main() {

let v = List(vec![1, 2, 3]);

println!("{}", v);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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:

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

See also:

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

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.

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

struct City {

name: &'static str,

// Latitude

lat: f32,

// Longitude

lon: f32,

}

impl Display for City {

// `f` is a buffer, and this method must write the formatted string into it

fn fmt(&self, f: &mut Formatter) -> fmt::Result {

let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' };

let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' };

// `write!` is like `format!`, but it will write the formatted string

// into a buffer (the first argument)

write!(f, "{}: {:.3}°{} {:.3}°{}",