877-display-trait — Display Trait

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"),
        }
    }
}

println!("{}", Color::Red);  // Display enables format!

type color = Red | Green | Blue

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

let () = Printf.printf "%s\n" (color_to_string Red)

#![allow(clippy::all)]
// Example 083: Display Trait
// OCaml to_string → Rust fmt::Display

use std::fmt;

// === Approach 1: Simple Display implementations ===
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"),
        }
    }
}

struct Point {
    x: f64,
    y: f64,
}

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

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

// === Approach 2: Multi-line Display (matrix) ===
struct Matrix {
    data: Vec<Vec<f64>>,
}

impl Matrix {
    fn new(data: Vec<Vec<f64>>) -> Self {
        Matrix { data }
    }
}

impl fmt::Display for Matrix {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for (i, row) in self.data.iter().enumerate() {
            write!(f, "| ")?;
            for (j, val) in row.iter().enumerate() {
                if j > 0 {
                    write!(f, " ")?;
                }
                write!(f, "{:6.2}", val)?;
            }
            write!(f, " |")?;
            if i < self.data.len() - 1 {
                writeln!(f)?;
            }
        }
        Ok(())
    }
}

// === Approach 3: Recursive Display (tree) ===
enum Tree<T> {
    Leaf,
    Node(Box<Tree<T>>, T, Box<Tree<T>>),
}

impl<T: fmt::Display> Tree<T> {
    fn node(left: Tree<T>, value: T, right: Tree<T>) -> Self {
        Tree::Node(Box::new(left), value, Box::new(right))
    }
}

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),
        }
    }
}

// Display enables .to_string() automatically
fn print_all<T: fmt::Display>(items: &[T]) -> String {
    items
        .iter()
        .map(|i| i.to_string())
        .collect::<Vec<_>>()
        .join(", ")
}

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

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

    #[test]
    fn test_point_display() {
        let p = Point { x: 1.0, y: 2.0 };
        assert_eq!(format!("{}", p), "(1.00, 2.00)");
    }

    #[test]
    fn test_point_debug() {
        let p = Point { x: 1.0, y: 2.0 };
        assert_eq!(format!("{:?}", p), "Point{ x: 1, y: 2 }");
    }

    #[test]
    fn test_matrix_display() {
        let m = Matrix::new(vec![vec![1.0, 2.0], vec![3.0, 4.0]]);
        let s = format!("{}", m);
        assert!(s.contains("1.00"));
        assert!(s.contains("4.00"));
    }

    #[test]
    fn test_tree_display() {
        let tree = Tree::node(Tree::Leaf, 42, Tree::Leaf);
        assert_eq!(format!("{}", tree), "(. 42 .)");
    }

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

    #[test]
    fn test_to_string() {
        let p = Point { x: 0.0, y: 0.0 };
        let s: String = p.to_string();
        assert_eq!(s, "(0.00, 0.00)");
    }

    #[test]
    fn test_print_all() {
        let colors = vec![Color::Red, Color::Green];
        assert_eq!(print_all(&colors), "Red, Green");
    }
}

(* Example 083: Display Trait *)
(* OCaml to_string → Rust fmt::Display *)

(* Approach 1: Custom to_string functions *)
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 "(%.2f, %.2f)" p.x p.y

(* Approach 2: Using Format module (like Rust's fmt) *)
type matrix = float array array

let matrix_to_string m =
  let rows = Array.map (fun row ->
    let cells = Array.map (fun v -> Printf.sprintf "%6.2f" v) row in
    "| " ^ String.concat " " (Array.to_list cells) ^ " |"
  ) m in
  String.concat "\n" (Array.to_list rows)

(* Approach 3: Recursive/nested 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)

(* Printf-compatible custom printer *)
let pp_point fmt p =
  Format.fprintf fmt "(%.2f, %.2f)" p.x p.y

let pp_color fmt c =
  Format.fprintf fmt "%s" (color_to_string c)

(* Tests *)
let () =
  assert (color_to_string Red = "Red");
  assert (color_to_string Blue = "Blue");

  let p = { x = 3.14; y = 2.72 } in
  assert (point_to_string p = "(3.14, 2.72)");

  let m = [| [| 1.0; 2.0 |]; [| 3.0; 4.0 |] |] in
  let s = matrix_to_string m in
  assert (String.length s > 0);

  let tree = Node (Node (Leaf, 1, Leaf), 2, Node (Leaf, 3, Leaf)) in
  let s = tree_to_string string_of_int tree in
  assert (s = "((. 1 .) 2 (. 3 .))");

  Printf.printf "✓ All tests passed\n"