Standard Traits & Operator Overloading

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
enum Condition {
    Poor,
    Fair,
    #[default]
    Good,
    LikeNew,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
struct ShelfCopy {
    shelf: String,
    condition: Condition,
}

fn main() {
    let a = ShelfCopy { shelf: "A1".into(), condition: Condition::Fair };
    let b = ShelfCopy { shelf: "A1".into(), ..Default::default() };
    println!("{a:?} < {b:?}: {}", a < b);                    // same shelf, Fair < Good: true
    println!("{:#?}", ShelfCopy::default());
    let mut copies = [b.clone(), a.clone()];
    copies.sort();
    println!("{:?}", copies.iter().map(|c| c.condition).collect::<Vec<_>>());
}

use std::fmt;

#[derive(Debug)]
struct Book {
    title: String,
    authors: Vec<String>,
    year: u16,
}

impl fmt::Display for Book {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} ({})", self.title, self.year)?;
        if f.alternate() {                                   // {:#} for a longer form
            write!(f, " by {}", self.authors.join(" and "))?;
        }
        Ok(())
    }
}

struct Isbn([u8; 13]);

impl fmt::Debug for Isbn {                                   // manual Debug: show digits compactly
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let digits: String = self.0.iter().map(|d| char::from(b'0' + d)).collect();
        f.debug_tuple("Isbn").field(&digits).finish()
    }
}

fn main() {
    let b = Book { title: "Good Omens".into(), authors: vec!["Pratchett".into(), "Gaiman".into()], year: 1990 };
    println!("{b}");               // Good Omens (1990)
    println!("{b:#}");             // Good Omens (1990) by Pratchett and Gaiman
    println!("{b:?}");
    println!("[{:>30}]", b.to_string()); // padding needs a String, or use f.pad in Display
    println!("{:?}", Isbn([9, 7, 8, 0, 4, 4, 1, 0, 1, 3, 5, 9, 3]));
}

use std::cmp::Ordering;
use std::collections::HashSet;
use std::hash::{Hash, Hasher};

/// A title compared case-insensitively.
#[derive(Debug, Clone)]
struct Title(String);

impl PartialEq for Title {
    fn eq(&self, other: &Self) -> bool {
        self.0.eq_ignore_ascii_case(&other.0)
    }
}
impl Eq for Title {}

impl Hash for Title {
    fn hash<H: Hasher>(&self, state: &mut H) {
        for b in self.0.bytes() {
            state.write_u8(b.to_ascii_lowercase()); // must agree with eq
        }
    }
}

impl PartialOrd for Title {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other)) // delegate to Ord: keeps them consistent
    }
}
impl Ord for Title {
    fn cmp(&self, other: &Self) -> Ordering {
        self.0.to_ascii_lowercase().cmp(&other.0.to_ascii_lowercase())
    }
}

fn main() {
    let set: HashSet<Title> = ["Dune", "DUNE", "Emma"].map(|t| Title(t.into())).into_iter().collect();
    println!("{}", set.len()); // 2
    let mut list = vec![Title("emma".into()), Title("Dune".into()), Title("beloved".into())];
    list.sort();
    println!("{list:?}");
    println!("{:?}", Title("a".into()).max(Title("B".into())));
}

use std::ops::{Add, AddAssign, Index, Mul, Neg};

#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
struct Money {
    cents: i64,
}

impl Add for Money {
    type Output = Money;
    fn add(self, rhs: Money) -> Money {
        Money { cents: self.cents + rhs.cents }
    }
}

impl Mul<i64> for Money {                // Money * integer, with a different Rhs type
    type Output = Money;
    fn mul(self, n: i64) -> Money {
        Money { cents: self.cents * n }
    }
}

impl Neg for Money {
    type Output = Money;
    fn neg(self) -> Money {
        Money { cents: -self.cents }
    }
}

impl AddAssign for Money {
    fn add_assign(&mut self, rhs: Money) {
        self.cents += rhs.cents;
    }
}

impl std::iter::Sum for Money {          // lets iterators of Money call .sum()
    fn sum<I: Iterator<Item = Money>>(iter: I) -> Money {
        iter.fold(Money::default(), Add::add)
    }
}

struct Ledger(Vec<Money>);

impl Index<usize> for Ledger {
    type Output = Money;
    fn index(&self, i: usize) -> &Money {
        &self.0[i]
    }
}

fn main() {
    let fee = Money { cents: 50 };
    let mut total = fee * 3 + Money { cents: 25 };
    total += -fee;
    let ledger = Ledger(vec![fee, total]);
    let sum: Money = ledger.0.iter().copied().sum();
    println!("{total:?} {:?} {sum:?}", ledger[1]); // Money { cents: 125 } ...
}