083 Intermediate

083 — Display Trait

Functional Programming

Tutorial

The Problem

Implement std::fmt::Display for custom types — Color, Point, Person, and a generic Tree<T> — to enable format!, println!, and to_string() without deriving Debug. Compare with OCaml's Printf.sprintf-based to_string functions for the same types.

🎯 Learning Outcomes

• Implement fmt::Display using write!(f, "...", ...) in the fmt method

• Understand fmt::Formatter as the sink that write! targets

• Use format specifiers like {:.1} for floating-point precision inside Display

• Implement Display for generic types with T: fmt::Display bound

• Distinguish Display (user-facing) from Debug (developer-facing)

• Map Rust's trait-based formatting to OCaml's explicit to_string functions

Code Example

#![allow(clippy::all)]
// 083: Display Trait
// Implement Display for custom types

use std::fmt;

// Approach 1: Simple Display
#[derive(Debug)]
enum Color {
    Red,
    Green,
    Blue,
}

impl fmt::Display for Color {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Color::Red => write!(f, "Red"),
            Color::Green => write!(f, "Green"),
            Color::Blue => write!(f, "Blue"),
        }
    }
}

#[derive(Debug)]
struct Point {
    x: f64,
    y: f64,
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({:.1}, {:.1})", self.x, self.y)
    }
}

// Approach 2: Complex formatting
#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
    email: String,
}

impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} (age {}, {})", self.name, self.age, self.email)
    }
}

// Approach 3: Recursive Display
#[derive(Debug)]
enum Tree<T> {
    Leaf,
    Node(Box<Tree<T>>, T, Box<Tree<T>>),
}

impl<T: fmt::Display> fmt::Display for Tree<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Tree::Leaf => write!(f, "."),
            Tree::Node(l, v, r) => write!(f, "({} {} {})", l, v, r),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_color_display() {
        assert_eq!(format!("{}", Color::Red), "Red");
        assert_eq!(format!("{}", Color::Green), "Green");
    }

    #[test]
    fn test_point_display() {
        assert_eq!(format!("{}", Point { x: 3.0, y: 4.0 }), "(3.0, 4.0)");
    }

    #[test]
    fn test_person_display() {
        let p = Person {
            name: "Alice".into(),
            age: 30,
            email: "alice@ex.com".into(),
        };
        assert_eq!(format!("{}", p), "Alice (age 30, alice@ex.com)");
    }

    #[test]
    fn test_tree_display() {
        let tree = Tree::Node(
            Box::new(Tree::Node(Box::new(Tree::Leaf), 1, Box::new(Tree::Leaf))),
            2,
            Box::new(Tree::Node(Box::new(Tree::Leaf), 3, Box::new(Tree::Leaf))),
        );
        assert_eq!(format!("{}", tree), "((. 1 .) 2 (. 3 .))");
    }
}

(* 083: Display — custom string representation *)

(* Approach 1: Simple to_string *)
type color = Red | Green | Blue

let color_to_string = function
  | Red -> "Red"
  | Green -> "Green"
  | Blue -> "Blue"

type point = { x: float; y: float }

let point_to_string p =
  Printf.sprintf "(%.1f, %.1f)" p.x p.y

(* Approach 2: Complex formatting *)
type person = { name: string; age: int; email: string }

let person_to_string p =
  Printf.sprintf "%s (age %d, %s)" p.name p.age p.email

let person_to_debug p =
  Printf.sprintf "{ name = %S; age = %d; email = %S }" p.name p.age p.email

(* Approach 3: Recursive display *)
type 'a tree = Leaf | Node of 'a tree * 'a * 'a tree

let rec tree_to_string to_s = function
  | Leaf -> "."
  | Node (l, v, r) ->
    Printf.sprintf "(%s %s %s)"
      (tree_to_string to_s l)
      (to_s v)
      (tree_to_string to_s r)

(* Tests *)
let () =
  assert (color_to_string Red = "Red");
  assert (point_to_string { x = 3.0; y = 4.0 } = "(3.0, 4.0)");
  let p = { name = "Alice"; age = 30; email = "alice@ex.com" } in
  assert (person_to_string p = "Alice (age 30, alice@ex.com)");
  let t = Node (Node (Leaf, 1, Leaf), 2, Node (Leaf, 3, Leaf)) in
  assert (tree_to_string string_of_int t = "((. 1 .) 2 (. 3 .))");
  Printf.printf "✓ All tests passed\n"

Key Differences

Aspect	Rust	OCaml
Interface	`impl fmt::Display` trait	`to_string` function per type
Generic elements	`T: fmt::Display` bound	`to_s : 'a -> string` parameter
Debug format	`#[derive(Debug)]`	`Printf.sprintf "%S"` / ppx
`to_string()`	Auto from `Display`	Explicit function
Sink type	`fmt::Formatter`	Returns `string` directly
Format spec	`{:.1}`, `{:>10}`, etc.	`%.1f`, `%10s`, etc.

Rust's Display trait integrates with the entire format!/println!/write! machinery. Any type that implements Display can be used in any format string {} position. OCaml's approach is more direct but requires explicitly threading the to_string function through generic code.

OCaml Approach

OCaml does not have a single Display trait; each type gets its own to_string function. Printf.sprintf "(%.1f, %.1f)" p.x p.y formats a point. For recursive tree, a higher-order tree_to_string to_s takes the element formatter as an argument, since OCaml has no trait-bound system. The result is the same string — the mechanism is different: explicit function passing vs trait dispatch.

Full Source

#![allow(clippy::all)]
// 083: Display Trait
// Implement Display for custom types

use std::fmt;

// Approach 1: Simple Display
#[derive(Debug)]
enum Color {
    Red,
    Green,
    Blue,
}

impl fmt::Display for Color {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Color::Red => write!(f, "Red"),
            Color::Green => write!(f, "Green"),
            Color::Blue => write!(f, "Blue"),
        }
    }
}

#[derive(Debug)]
struct Point {
    x: f64,
    y: f64,
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({:.1}, {:.1})", self.x, self.y)
    }
}

// Approach 2: Complex formatting
#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
    email: String,
}

impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} (age {}, {})", self.name, self.age, self.email)
    }
}

// Approach 3: Recursive Display
#[derive(Debug)]
enum Tree<T> {
    Leaf,
    Node(Box<Tree<T>>, T, Box<Tree<T>>),
}

impl<T: fmt::Display> fmt::Display for Tree<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Tree::Leaf => write!(f, "."),
            Tree::Node(l, v, r) => write!(f, "({} {} {})", l, v, r),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_color_display() {
        assert_eq!(format!("{}", Color::Red), "Red");
        assert_eq!(format!("{}", Color::Green), "Green");
    }

    #[test]
    fn test_point_display() {
        assert_eq!(format!("{}", Point { x: 3.0, y: 4.0 }), "(3.0, 4.0)");
    }

    #[test]
    fn test_person_display() {
        let p = Person {
            name: "Alice".into(),
            age: 30,
            email: "alice@ex.com".into(),
        };
        assert_eq!(format!("{}", p), "Alice (age 30, alice@ex.com)");
    }

    #[test]
    fn test_tree_display() {
        let tree = Tree::Node(
            Box::new(Tree::Node(Box::new(Tree::Leaf), 1, Box::new(Tree::Leaf))),
            2,
            Box::new(Tree::Node(Box::new(Tree::Leaf), 3, Box::new(Tree::Leaf))),
        );
        assert_eq!(format!("{}", tree), "((. 1 .) 2 (. 3 .))");
    }
}

(* 083: Display — custom string representation *)

(* Approach 1: Simple to_string *)
type color = Red | Green | Blue

let color_to_string = function
  | Red -> "Red"
  | Green -> "Green"
  | Blue -> "Blue"

type point = { x: float; y: float }

let point_to_string p =
  Printf.sprintf "(%.1f, %.1f)" p.x p.y

(* Approach 2: Complex formatting *)
type person = { name: string; age: int; email: string }

let person_to_string p =
  Printf.sprintf "%s (age %d, %s)" p.name p.age p.email

let person_to_debug p =
  Printf.sprintf "{ name = %S; age = %d; email = %S }" p.name p.age p.email

(* Approach 3: Recursive display *)
type 'a tree = Leaf | Node of 'a tree * 'a * 'a tree

let rec tree_to_string to_s = function
  | Leaf -> "."
  | Node (l, v, r) ->
    Printf.sprintf "(%s %s %s)"
      (tree_to_string to_s l)
      (to_s v)
      (tree_to_string to_s r)

(* Tests *)
let () =
  assert (color_to_string Red = "Red");
  assert (point_to_string { x = 3.0; y = 4.0 } = "(3.0, 4.0)");
  let p = { name = "Alice"; age = 30; email = "alice@ex.com" } in
  assert (person_to_string p = "Alice (age 30, alice@ex.com)");
  let t = Node (Node (Leaf, 1, Leaf), 2, Node (Leaf, 3, Leaf)) in
  assert (tree_to_string string_of_int t = "((. 1 .) 2 (. 3 .))");
  Printf.printf "✓ All tests passed\n"

✓ Tests Rust test suite

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_color_display() {
        assert_eq!(format!("{}", Color::Red), "Red");
        assert_eq!(format!("{}", Color::Green), "Green");
    }

    #[test]
    fn test_point_display() {
        assert_eq!(format!("{}", Point { x: 3.0, y: 4.0 }), "(3.0, 4.0)");
    }

    #[test]
    fn test_person_display() {
        let p = Person {
            name: "Alice".into(),
            age: 30,
            email: "alice@ex.com".into(),
        };
        assert_eq!(format!("{}", p), "Alice (age 30, alice@ex.com)");
    }

    #[test]
    fn test_tree_display() {
        let tree = Tree::Node(
            Box::new(Tree::Node(Box::new(Tree::Leaf), 1, Box::new(Tree::Leaf))),
            2,
            Box::new(Tree::Node(Box::new(Tree::Leaf), 3, Box::new(Tree::Leaf))),
        );
        assert_eq!(format!("{}", tree), "((. 1 .) 2 (. 3 .))");
    }
}

Deep Comparison

Core Insight

Display controls how a type is printed with {}. Unlike Debug (derived), Display must be manually implemented — it's the user-facing representation.

OCaml Approach

• Write to_string function manually

• Use Printf.sprintf with format strings

• No unified "display" protocol

Rust Approach

• impl fmt::Display for Type

• Enables format!("{}", x), println!("{}", x)

• Single fmt method returns fmt::Result

Comparison Table

Feature	OCaml	Rust
Protocol	Manual `to_string`	`impl Display`
Format string	`%s` with `to_string`	`{}` automatic
Debug	`#show` (ppx)	`#[derive(Debug)]`
Derive	No	Display: no, Debug: yes

Exercises

Implement fmt::Display for a Matrix(Vec<Vec<f64>>) newtype that prints rows separated by newlines.

Add an impl fmt::Display for Tree<T> variant that prints in indented format (each level adds two spaces).

Implement fmt::Debug manually for Person to show Person { name: "Alice", age: 30, email: "…" }.

Write a Wrapper<T: Display>(Vec<T>) that displays its items as [a, b, c].

In OCaml, define a Printable module type with val to_string : t -> string and a functor PrintList(P: Printable) with val print_list : P.t list -> string.

Open Source Repos

functional-rust

View the source for this example on GitHub — OCaml and Rust side by side in the repo.

Rust