Traits & Generics

trait Summary {
    fn author(&self) -> String;                        // required: no body

    fn summarize(&self) -> String {                    // default method
        format!("(Read more from {}...)", self.author())
    }
}

struct Tweet {
    user: String,
    text: String,
}

struct Article {
    title: String,
    by: String,
}

impl Summary for Tweet {
    fn author(&self) -> String {
        format!("@{}", self.user)
    }
    fn summarize(&self) -> String {                    // overrides the default
        format!("{}: {}", self.author(), self.text)
    }
}

impl Summary for Article {
    fn author(&self) -> String {
        self.by.clone()
    }                                                  // keeps the default summarize
}

fn main() {
    let t = Tweet { user: String::from("rustlang"), text: String::from("1.0 is out") };
    let a = Article { title: String::from("Traits"), by: String::from("Ada") };
    println!("{}", t.summarize());
    println!("{} {}", a.title, a.summarize());
}

use std::fmt::Display;

// 1. Inline bound
fn largest<T: PartialOrd>(items: &[T]) -> &T {
    let mut best = &items[0];
    for item in items {
        if item > best {
            best = item;
        }
    }
    best
}

// 2. where clause: easier to read with several bounds
fn show_pair<A, B>(a: A, b: B) -> String
where
    A: Display,
    B: Display + Clone,           // + means "both traits"
{
    format!("<{a}, {b}>")
}

// 3. impl Trait in argument position: shorthand for a simple bound
fn shout(msg: impl Display) -> String {
    format!("{}!", msg.to_string().to_uppercase())
}

fn main() {
    println!("{}", largest(&[3, 9, 4]));
    println!("{}", largest(&[1.5, -2.0]));
    println!("{}", largest(&["pear", "apple", "zucchini"]));
    println!("{}", show_pair(1, "one"));
    println!("{} {}", shout("hi"), shout(42));
}

fn evens_squared(limit: u32) -> impl Iterator<Item = u32> {
    (1..=limit).filter(|n| n % 2 == 0).map(|n| n * n)
}

fn make_adder(k: i32) -> impl Fn(i32) -> i32 {
    move |x| x + k
}

fn main() {
    let v: Vec<u32> = evens_squared(10).collect();
    println!("{:?}", v);
    let add5 = make_adder(5);
    println!("{}", add5(10));
}

#[derive(Debug)]
struct Pair<T> {
    a: T,
    b: T,
}

impl<T> Pair<T> {                         // for every T
    fn new(a: T, b: T) -> Self {
        Pair { a, b }
    }
    fn swap(self) -> Pair<T> {
        Pair { a: self.b, b: self.a }
    }
}

impl<T: PartialOrd + Copy> Pair<T> {      // only when T can be compared and copied
    fn max(&self) -> T {
        if self.a > self.b { self.a } else { self.b }
    }
}

#[derive(Debug)]
enum Tree<T> {                            // a generic enum
    Leaf(T),
    Node(Box<Tree<T>>, Box<Tree<T>>),
}

fn count<T>(t: &Tree<T>) -> usize {
    match t {
        Tree::Leaf(_) => 1,
        Tree::Node(l, r) => count(l) + count(r),
    }
}

fn main() {
    let p = Pair::new(3, 8);
    println!("{:?} max={}", p, p.max());
    println!("{:?}", p.swap());

    let words = Pair::new(String::from("x"), String::from("y"));
    println!("{:?}", words.swap());         // no max(): String is not Copy

    let t = Tree::Node(Box::new(Tree::Leaf('a')), Box::new(Tree::Node(Box::new(Tree::Leaf('b')), Box::new(Tree::Leaf('c')))));
    println!("leaves: {}", count(&t));
}

use std::fmt;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum Priority {
    Low,                  // declared first = smallest
    Medium,
    High,
}

#[derive(Debug, PartialEq, PartialOrd)]
struct Version {
    major: u32,           // compared first
    minor: u32,           // only if major is equal
    patch: u32,
}

impl fmt::Display for Version {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "v{}.{}.{}", self.major, self.minor, self.patch)
    }
}

fn main() {
    let a = Version { major: 1, minor: 10, patch: 0 };
    let b = Version { major: 1, minor: 9, patch: 7 };
    println!("{a} > {b}? {}", a > b);      // 10 > 9 decides it
    println!("{:?}", b);                   // Debug: derived
    println!("[{:>10}]", a.to_string());   // Display gives you to_string()

    let mut tasks = vec![Priority::Medium, Priority::High, Priority::Low];
    tasks.sort();                          // needs Ord
    println!("{:?} max={:?}", tasks, tasks.iter().max().unwrap());
}

use std::cmp::Ordering;

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

impl PartialOrd for Player {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        other.score.partial_cmp(&self.score)       // reversed: higher score sorts first
    }
}

fn main() {
    let mut board = vec![
        Player { name: String::from("kim"), score: 40 },
        Player { name: String::from("ana"), score: 95 },
        Player { name: String::from("raj"), score: 70 },
    ];
    board.sort_by(|x, y| x.partial_cmp(y).unwrap());
    for p in &board {
        println!("{:<4}{}", p.name, p.score);
    }
}

trait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> &str;
}

struct Circle { r: f64 }
struct Rect { w: f64, h: f64 }

impl Shape for Circle {
    fn area(&self) -> f64 { 3.14159 * self.r * self.r }
    fn name(&self) -> &str { "circle" }
}

impl Shape for Rect {
    fn area(&self) -> f64 { self.w * self.h }
    fn name(&self) -> &str { "rect" }
}

fn total_area(shapes: &[Box<dyn Shape>]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

fn main() {
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { r: 1.0 }),
        Box::new(Rect { w: 2.0, h: 3.0 }),
        Box::new(Circle { r: 0.5 }),
    ];
    for s in &shapes {
        println!("{:<6} {:.2}", s.name(), s.area());
    }
    println!("total  {:.2}", total_area(&shapes));
}

use std::fmt;

struct Csv(Vec<String>);                // newtype: local, so we may implement Display

impl fmt::Display for Csv {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.0.join(","))
    }
}

trait Describe {                         // a local trait...
    fn describe(&self) -> String;
}

impl Describe for i32 {                  // ...may be implemented for a foreign type
    fn describe(&self) -> String {
        if *self < 0 { format!("{self} (negative)") } else { format!("{self}") }
    }
}

fn main() {
    let row = Csv(vec![String::from("id"), String::from("name"), String::from("email")]);
    println!("{row}");
    println!("{} | {}", 7.describe(), (-3).describe());
}

use std::ops::{Add, Mul};

#[derive(Debug, Clone, Copy, PartialEq)]
struct Vec2 {
    x: f64,
    y: f64,
}

impl Add for Vec2 {
    type Output = Vec2;                  // associated type: what + returns
    fn add(self, other: Vec2) -> Vec2 {
        Vec2 { x: self.x + other.x, y: self.y + other.y }
    }
}

impl Mul<f64> for Vec2 {                 // Vec2 * f64 (a different right-hand type)
    type Output = Vec2;
    fn mul(self, k: f64) -> Vec2 {
        Vec2 { x: self.x * k, y: self.y * k }
    }
}

fn sum_all<T: Add<Output = T> + Copy>(items: &[T], zero: T) -> T {
    let mut acc = zero;
    for &i in items {
        acc = acc + i;
    }
    acc
}

fn main() {
    let a = Vec2 { x: 1.0, y: 2.0 };
    let b = Vec2 { x: 0.5, y: -1.0 };
    println!("{:?}", a + b);
    println!("{:?}", a * 3.0);
    println!("{}", a + b == Vec2 { x: 1.5, y: 1.0 });
    println!("{:?}", sum_all(&[a, b, a], Vec2 { x: 0.0, y: 0.0 }));
    println!("{}", sum_all(&[1, 2, 3], 0));   // the same function on i32
}