Display and Comparison Traits

🎭 The Trait Show: How Rust Types Express Themselves

Imagine you have a toy box full of different toys. Each toy needs to know how to introduce itself, how to be compared with other toys, and how to show what it’s made of. In Rust, we use special “talents” called traits to give our types these abilities!

🌟 The Big Picture: A Town of Talents

Picture a small town where everyone has special talents:

• Display is like the Town Announcer – speaks beautifully to everyone
• Debug is like the Detective – shows every tiny detail
• PartialEq is like asking “Are you my twin?”
• Eq is like saying “We’re EXACTLY the same!”
• PartialOrd is like “Who’s taller… maybe?”
• Ord is like “I can line up EVERYONE by height!”

Let’s meet each one!

📢 Display Trait: The Town Announcer

What is Display?

The Display trait is how your type says “Hello, world!” in a pretty, human-friendly way.

Think of it like this: when you introduce yourself to a new friend, you say “Hi, I’m Alex!” – not “Human { name: Alex, age: 8, hair: brown }”.

Simple Example

use std::fmt;

struct Pet {
    name: String,
    kind: String,
}

impl fmt::Display for Pet {
    fn fmt(&self, f: &mut fmt::Formatter)
        -> fmt::Result {
        write!(f, "{} the {}",
            self.name, self.kind)
    }
}

fn main() {
    let dog = Pet {
        name: String::from("Buddy"),
        kind: String::from("Dog"),
    };
    println!("{}", dog);
    // Prints: Buddy the Dog
}

🎯 Key Points

• Use {} in println! to trigger Display
• You must implement it yourself for custom types
• It’s meant for end users to read

🔍 Debug Trait: The Detective

What is Debug?

Debug is like a detective’s magnifying glass. It shows EVERYTHING about your type, even the boring parts.

When your code breaks, Debug helps you peek inside and see what went wrong!

Simple Example

#[derive(Debug)]
struct Backpack {
    pencils: u8,
    books: u8,
    snacks: u8,
}

fn main() {
    let my_bag = Backpack {
        pencils: 3,
        books: 2,
        snacks: 5,
    };
    println!("{:?}", my_bag);
    // Backpack { pencils: 3,
    //   books: 2, snacks: 5 }
}

🎯 Key Points

• Use {:?} for Debug output
• Use {:#?} for pretty printing (nicely formatted)
• Add #[derive(Debug)] for automatic implementation
• It’s meant for developers to debug

🎨 Formatting Options: Dress Up Your Output!

Rust gives you special codes to format your output like picking outfits for your toys!

The Formatting Menu

Example

fn main() {
    let num = 42;

    println!("Normal: {}", num);
    println!("Binary: {:b}", num);
    println!("Hex: {:x}", num);

    let pi = 3.14159;
    println!("Short pi: {:.2}", pi);
    // Prints: 3.14
}

⚖️ PartialEq Trait: The Twin Checker

What is PartialEq?

PartialEq lets you ask: “Are these two things equal?”

It’s called “partial” because sometimes things can’t be compared (like comparing apples to spaceships… or NaN to anything!).

Simple Example

#[derive(PartialEq)]
struct Cookie {
    flavor: String,
    chips: u8,
}

fn main() {
    let cookie1 = Cookie {
        flavor: String::from("chocolate"),
        chips: 10,
    };
    let cookie2 = Cookie {
        flavor: String::from("chocolate"),
        chips: 10,
    };

    if cookie1 == cookie2 {
        println!("Same cookie!");
    }
    // Prints: Same cookie!
}

🎯 Key Points

• Enables == and != operators
• Use #[derive(PartialEq)] for automatic implementation
• “Partial” means some values might not be comparable

✨ Eq Trait: The Perfect Twin

What is Eq?

Eq is PartialEq’s stricter sibling. It’s a promise that EVERY value of your type can be compared with itself and it ALWAYS equals itself.

Think of it like this:

• PartialEq: “We might be twins”
• Eq: “We are DEFINITELY identical twins, no exceptions!”

Simple Example

#[derive(PartialEq, Eq)]
struct Student {
    id: u32,
    name: String,
}

fn main() {
    let student = Student {
        id: 1,
        name: String::from("Alice"),
    };

    // Eq guarantees: student == student
    // is ALWAYS true!
}

🎯 Key Points

• Eq requires PartialEq first
• Eq is a “marker trait” – no extra methods
• Floats (f32, f64) can’t be Eq because of NaN

📏 PartialOrd Trait: The Height Comparer

What is PartialOrd?

PartialOrd lets you ask: “Is this bigger, smaller, or equal?”

It’s “partial” because sometimes you can’t compare (like comparing a banana to the number 7).

Simple Example

#[derive(PartialEq, PartialOrd)]
struct Height {
    centimeters: u32,
}

fn main() {
    let alice = Height { centimeters: 120 };
    let bob = Height { centimeters: 130 };

    if alice < bob {
        println!("Alice is shorter!");
    }
    // Prints: Alice is shorter!
}

The Compare Menu

alice < bob   // less than
alice > bob   // greater than
alice <= bob  // less than or equal
alice >= bob  // greater than or equal

🎯 Key Points

• Enables <, >, <=, >= operators
• Requires PartialEq
• Returns Option<Ordering> (might be None!)

🏆 Ord Trait: The Perfect Line-Up

What is Ord?

Ord is the complete ordering trait. It promises that ANY two values can be compared and put in order – no exceptions!

Think of lining up kids by height. Ord guarantees everyone can find their place in line.

Simple Example

#[derive(PartialEq, Eq,
         PartialOrd, Ord)]
struct Score {
    points: u32,
}

fn main() {
    let mut scores = vec![
        Score { points: 50 },
        Score { points: 100 },
        Score { points: 25 },
    ];

    scores.sort();  // Uses Ord!

    for s in &scores {
        println!("{}", s.points);
    }
    // Prints: 25, 50, 100
}

🎯 Key Points

• Ord requires Eq + PartialOrd
• Enables .sort(), .max(), .min()
• Returns Ordering (always works, never None)

🗺️ The Trait Family Tree

graph TD
    A["PartialEq"] --> B["Eq"]
    A --> C["PartialOrd"]
    C --> D["Ord"]
    B --> D

    style A fill:#74b9ff
    style B fill:#55efc4
    style C fill:#fdcb6e
    style D fill:#e17055

Remember:

• Eq needs PartialEq
• PartialOrd needs PartialEq
• Ord needs Eq AND PartialOrd

🎁 Quick Derive Magic

Most of the time, you can just ask Rust to figure it out:

#[derive(Debug, Clone,
         PartialEq, Eq,
         PartialOrd, Ord)]
struct Player {
    score: u32,
    name: String,
}

One line, all the powers! ✨

🧠 When to Use What?

🎬 Final Scene: All Together!

use std::fmt;

#[derive(Debug, PartialEq, Eq,
         PartialOrd, Ord)]
struct Hero {
    power: u32,
    name: String,
}

impl fmt::Display for Hero {
    fn fmt(&self, f: &mut fmt::Formatter)
        -> fmt::Result {
        write!(f, "⚡ {} (Power: {})",
            self.name, self.power)
    }
}

fn main() {
    let heroes = vec![
        Hero { power: 100,
               name: String::from("Spark") },
        Hero { power: 50,
               name: String::from("Blaze") },
    ];

    // Display - pretty for users
    println!("{}", heroes[0]);

    // Debug - detailed for devs
    println!("{:?}", heroes[0]);

    // PartialEq - are they equal?
    println!("{}", heroes[0] == heroes[1]);

    // PartialOrd - who's stronger?
    println!("{}", heroes[0] > heroes[1]);
}

🌈 You Did It!

Now you know how Rust types:

• 📢 Speak (Display & Debug)
• ⚖️ Compare (PartialEq & Eq)
• 📏 Order (PartialOrd & Ord)

These traits are like superpowers for your types. The more you use them, the more powerful your Rust code becomes!

Go forth and give your types a voice! 🦀✨