Change:
Someone looking at some code with, say, might search the docs for and land on , which doesn't make it immediately obvious what it is for (it currently just says "Format trait for the :? format. Useful for debugging, all types should implement this."). It would be great if each trait had an example of using it to format something and maybe an explicit pointer to the main docs.

Discussion:
} } <del> /// Format trait for the `?` character. Useful for debugging, all types /// should implement this. </del> <ins> /// Format trait for the `?` character. /// /// `Debug` should format the output in a programmer-facing, debugging context. </ins> /// /// Generally speaking, you should just `derive` a `Debug` implementation. /// <ins> /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// </ins> /// # Examples /// /// Deriving an implementation:

fn fmt(&self, &mut Formatter) -> Result; } <del> /// When a value can be semantically expressed as a String, this trait may be /// used. It corresponds to the default format, `{}`. </del> <ins> /// Format trait for an empty format, `{}`. /// /// `Display` is similar to [`Debug`][debug], but `Display` is for user-facing /// output, and so cannot be derived. /// /// [debug]: trait.Debug.html /// /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// /// # Examples /// /// Implementing `Display` on a type: /// /// ``` /// use std::fmt; /// /// struct Point { ///     x: i32, ///     y: i32, /// } /// /// impl fmt::Display for Point { ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ///         write!(f, "({}, {})", self.x, self.y) ///     } /// } /// /// let origin = Point { x: 0, y: 0 }; /// /// println!("The origin is: {}", origin); /// ``` </ins> #[rustc_on_unimplemented = "`{Self}` cannot be formatted with the default  formatter; try using `:?` instead if you are using  a format string"]

fn fmt(&self, &mut Formatter) -> Result; } <del> /// Format trait for the `o` character </del> <ins> /// Format trait for the `o` character. /// /// The `Octal` trait should format its output as a number in base-8. /// /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// /// # Examples /// /// Basic usage with `i32`: /// /// ``` /// let x = 42; // 42 is '52' in octal /// /// assert_eq!(format!("{:o}", x), "52"); /// ``` /// /// Implementing `Octal` on a type: /// /// ``` /// use std::fmt; /// /// struct Length(i32); /// /// impl fmt::Octal for Length { ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ///         let val = self.0; /// ///         write!(f, "{:o}", val) // delegate to i32's implementation ///     } /// } /// /// let l = Length(9); /// /// println!("l as octal is: {:o}", l); /// ``` </ins> #[stable(feature = "rust1", since = "1.0.0")] pub trait Octal { /// Formats the value using the given formatter.

fn fmt(&self, &mut Formatter) -> Result; } <del> /// Format trait for the `b` character </del> <ins> /// Format trait for the `b` character. /// /// The `Binary` trait should format its output as a number in binary. /// /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// /// # Examples /// /// Basic usage with `i32`: /// /// ``` /// let x = 42; // 42 is '101010' in binary /// /// assert_eq!(format!("{:b}", x), "101010"); /// ``` /// /// Implementing `Binary` on a type: /// /// ``` /// use std::fmt; /// /// struct Length(i32); /// /// impl fmt::Binary for Length { ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ///         let val = self.0; /// ///         write!(f, "{:b}", val) // delegate to i32's implementation ///     } /// } /// /// let l = Length(107); /// /// println!("l as binary is: {:b}", l); /// ``` </ins> #[stable(feature = "rust1", since = "1.0.0")] pub trait Binary { /// Formats the value using the given formatter.

fn fmt(&self, &mut Formatter) -> Result; } <del> /// Format trait for the `x` character </del> <ins> /// Format trait for the `x` character. /// /// The `LowerHex` trait should format its output as a number in hexidecimal, with `a` through `f` /// in lower case. /// /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// /// # Examples /// /// Basic usage with `i32`: /// /// ``` /// let x = 42; // 42 is '2a' in hex /// /// assert_eq!(format!("{:x}", x), "2a"); /// ``` /// /// Implementing `LowerHex` on a type: /// /// ``` /// use std::fmt; /// /// struct Length(i32); /// /// impl fmt::LowerHex for Length { ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ///         let val = self.0; /// ///         write!(f, "{:x}", val) // delegate to i32's implementation ///     } /// } /// /// let l = Length(9); /// /// println!("l as hex is: {:x}", l); /// ``` </ins> #[stable(feature = "rust1", since = "1.0.0")] pub trait LowerHex { /// Formats the value using the given formatter.

fn fmt(&self, &mut Formatter) -> Result; } <del> /// Format trait for the `X` character </del> <ins> /// Format trait for the `X` character. /// /// The `UpperHex` trait should format its output as a number in hexidecimal, with `A` through `F` /// in upper case. /// /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// /// # Examples /// /// Basic usage with `i32`: /// /// ``` /// let x = 42; // 42 is '2A' in hex /// /// assert_eq!(format!("{:X}", x), "2A"); /// ``` /// /// Implementing `UpperHex` on a type: /// /// ``` /// use std::fmt; /// /// struct Length(i32); /// /// impl fmt::UpperHex for Length { ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ///         let val = self.0; /// ///         write!(f, "{:X}", val) // delegate to i32's implementation ///     } /// } /// /// let l = Length(9); /// /// println!("l as hex is: {:X}", l); /// ``` </ins> #[stable(feature = "rust1", since = "1.0.0")] pub trait UpperHex { /// Formats the value using the given formatter.

fn fmt(&self, &mut Formatter) -> Result; } <del> /// Format trait for the `p` character </del> <ins> /// Format trait for the `p` character. /// /// The `Pointer` trait should format its output as a memory location. This is commonly presented /// as hexidecimal. /// /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// /// # Examples /// /// Basic usage with `&i32`: /// /// ``` /// let x = &42; /// /// let address = format!("{:p}", x); // this produces something like '0x7f06092ac6d0' /// ``` /// /// Implementing `Pointer` on a type: /// /// ``` /// use std::fmt; /// /// struct Length(i32); /// /// impl fmt::Pointer for Length { ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ///         // use `as` to convert to a `*const T`, which implements Pointer, which we can use /// ///         write!(f, "{:p}", self as *const Length) ///     } /// } /// /// let l = Length(42); /// /// println!("l is in memory here: {:p}", l); /// ``` </ins> #[stable(feature = "rust1", since = "1.0.0")] pub trait Pointer { /// Formats the value using the given formatter.

fn fmt(&self, &mut Formatter) -> Result; } <del> /// Format trait for the `e` character </del> <ins> /// Format trait for the `e` character. /// /// The `LowerExp` trait should format its output in scientific notation with a lower-case `e`. /// /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// /// # Examples /// /// Basic usage with `i32`: /// /// ``` /// let x = 42.0; // 42.0 is '4.2e1' in scientific notation /// /// assert_eq!(format!("{:e}", x), "4.2e1"); /// ``` /// /// Implementing `LowerExp` on a type: /// /// ``` /// use std::fmt; /// /// struct Length(i32); /// /// impl fmt::LowerExp for Length { ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ///         let val = self.0; ///         write!(f, "{}e1", val / 10) ///     } /// } /// /// let l = Length(100); /// /// println!("l in scientific notation is: {:e}", l); /// ``` </ins> #[stable(feature = "rust1", since = "1.0.0")] pub trait LowerExp { /// Formats the value using the given formatter.

fn fmt(&self, &mut Formatter) -> Result; } <del> /// Format trait for the `E` character </del> <ins> /// Format trait for the `E` character. /// /// The `UpperExp` trait should format its output in scientific notation with an upper-case `E`. /// /// For more information on formatters, see [the module-level documentation][module]. /// /// [module]: ../index.html /// /// # Examples /// /// Basic usage with `f32`: /// /// ``` /// let x = 42.0; // 42.0 is '4.2E1' in scientific notation /// /// assert_eq!(format!("{:E}", x), "4.2E1"); /// ``` /// /// Implementing `UpperExp` on a type: /// /// ``` /// use std::fmt; /// /// struct Length(i32); /// /// impl fmt::UpperExp for Length { ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ///         let val = self.0; ///         write!(f, "{}E1", val / 10) ///     } /// } /// /// let l = Length(100); /// /// println!("l in scientific notation is: {:E}", l); /// ``` </ins> #[stable(feature = "rust1", since = "1.0.0")] pub trait UpperExp { /// Formats the value using the given formatter.