Generic Functions and Types

// Generic function
fn largest(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest { largest = item; }
    }
    largest
}

// Generic struct
#[derive(Debug)]
struct Pair {
    first: T,
    second: T,
}

impl Pair {
    fn new(first: T, second: T) -> Self { Pair { first, second } }
    fn max(&self) -> &T {
        if self.first > self.second { &self.first } else { &self.second }
    }
    fn swap(self) -> Pair { Pair::new(self.second, self.first) }
}

// Generic enum (you already know Option and Result)
#[derive(Debug)]
enum Either { Left(L), Right(R) }

fn divide(a: f64, b: f64) -> Either {
    if b == 0.0 { Either::Right("division by zero".to_string()) }
    else { Either::Left(a / b) }
}

fn main() {
    let nums = vec![34, 50, 25, 100, 65];
    println!("Largest: {}", largest(&nums));

    let strs = vec!["hello", "world", "rust"];
    println!("Largest: {}", largest(&strs));

    let p = Pair::new(5, 10);
    println!("Max: {}", p.max());

    match divide(10.0, 3.0) {
        Either::Left(result) => println!("{:.4}", result),
        Either::Right(err) => println!("Error: {}", err),
    }
}