Traits &
Generics

// Define a trait — like an interface in other languages
trait Greet {
    fn name(&self) -> &str;

    // Default implementation — free for any implementor
    fn hello(&self) {
        println!("Hello, my name is {}!", self.name());
    }
}

struct Human { name: String }
struct Robot  { model: String }

impl Greet for Human {
    fn name(&self) -> &str { &self.name }
    // `hello` — uses the default implementation above
}

impl Greet for Robot {
    fn name(&self) -> &str { &self.model }
    // Override default for robots
    fn hello(&self) {
        println!("BEEP. Designation: {}. BOOP.", self.name());
    }
}

fn main() {
    let h = Human { name: String::from("Mishal") };
    let r = Robot  { model: String::from("R2-D2")  };

    h.hello(); // "Hello, my name is Mishal!"  (default)
    r.hello(); // "BEEP. Designation: R2-D2. BOOP."  (overridden)
}

// Generic function — T must implement Greet
fn introduce<T: Greet>(entity: &T) {
    println!("Introducing: {}", entity.name());
    entity.hello();
}

// Multiple trait bounds with + syntax
use std::fmt::Debug;

fn introduce_and_debug<T: Greet + Debug>(entity: &T) {
    entity.hello();
    println!("Debug view: {:?}", entity);
}

// Same thing using WHERE CLAUSE — easier to read with many bounds
fn introduce_where<T>(entity: &T)
where
    T: Greet + Debug,
{
    entity.hello();
    println!("Debug: {:?}", entity);
}

#[derive(Debug)]
struct Human { name: String }
impl Greet for Human {
    fn name(&self) -> &str { &self.name }
}

fn main() {
    let h = Human { name: String::from("Mishal") };
    introduce(&h);
    introduce_where(&h);
}

use std::fmt::Display;

// PARAMETER position — same as fn foo<T: Display>(val: T)
// Difference: with impl Trait here, each param gets its OWN anonymous type.
// fn foo(a: impl Display, b: impl Display) could be two DIFFERENT types.
fn print_value(val: impl Display) {
    println!("Value: {}", val);
}

// RETURN position — "I return something that impl Display, but won't tell you what type"
// Compiler knows the concrete type and optimises it — static dispatch
fn make_greeting(name: &str) -> impl Display {
    format!("Hello, {}!", name) // returns String, but caller sees `impl Display`
}

// KEY USE CASE: returning closures — closures have unique unnameable types
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y  // the closure captures x — its type is unnameable
}

// KEY USE CASE: returning iterators — iterator types are deeply nested
fn evens_up_to(n: u32) -> impl Iterator<Item = u32> {
    (0..=n).filter(|x| x % 2 == 0)
    // actual type: Filter<RangeInclusive<u32>, [closure]> — you don't want to type this
}

fn main() {
    print_value(42);
    print_value("hello");
    println!("{}", make_greeting("Mishal"));

    let add5 = make_adder(5);
    println!("5 + 3 = {}", add5(3));

    let evens: Vec<_> = evens_up_to(10).collect();
    println!("{:?}", evens); // [0, 2, 4, 6, 8, 10]
}

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

struct Circle { radius: f64 }
struct Rectangle { width: f64, height: f64 }

impl Shape for Circle {
    fn area(&self)   -> f64  { std::f64::consts::PI * self.radius * self.radius }
    fn name(&self)   -> &str  { "Circle" }
}
impl Shape for Rectangle {
    fn area(&self)   -> f64  { self.width * self.height }
    fn name(&self)   -> &str  { "Rectangle" }
}

// `shapes` holds DIFFERENT types — impossible with generics alone
// Box<dyn Shape> is a fat pointer: (data ptr, vtable ptr)
fn print_shapes(shapes: &[Box<dyn Shape>]) {
    for shape in shapes {
        println!("{}: area = {:.2}", shape.name(), shape.area());
    }
}

fn main() {
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle    { radius: 3.0             }),
        Box::new(Rectangle { width: 4.0, height: 5.0 }),
        Box::new(Circle    { radius: 1.5             }),
    ];

    print_shapes(&shapes);
    // Circle:    area = 28.27
    // Rectangle: area = 20.00
    // Circle:    area = 7.07
}

trait Speak {
    fn speak(&self) -> String;
}

struct Dog;
struct Cat;
impl Speak for Dog { fn speak(&self) -> String { "Woof!".into() } }
impl Speak for Cat { fn speak(&self) -> String { "Meow!".into() } }

// --- impl Trait (static dispatch) ---
// Compiler generates: fn static_speak_Dog, fn static_speak_Cat
// Zero runtime overhead. ONE concrete type per call.
fn static_speak(animal: &impl Speak) {
    println!("[static]  {}", animal.speak());
}

// --- dyn Trait (dynamic dispatch) ---
// ONE function body, handles ANY Speak type at runtime via vtable.
// Slight overhead per call — but allows heterogeneous collections.
fn dynamic_speak(animal: &dyn Speak) {
    println!("[dynamic] {}", animal.speak());
}

fn main() {
    let dog = Dog;
    let cat = Cat;

    // static: fast, type known at compile time
    static_speak(&dog); // [static]  Woof!
    static_speak(&cat); // [static]  Meow!

    // dynamic: heterogeneous Vec possible
    let animals: Vec<&dyn Speak> = vec![&dog, &cat];
    for a in &animals {
        dynamic_speak(*a);
    }
    // [dynamic] Woof!
    // [dynamic] Meow!

    // ❌ This would NOT compile with impl Trait in return position
    //    if we want different types based on runtime condition:
    // fn pick_animal(is_dog: bool) -> impl Speak {
    //     if is_dog { Dog } else { Cat }  // ❌ ERROR: mismatched types
    // }

    // ✅ Use Box<dyn Speak> instead:
    fn pick_animal(is_dog: bool) -> Box<dyn Speak> {
        if is_dog { Box::new(Dog) } else { Box::new(Cat) }
    }
    println!("{}", pick_animal(true).speak()); // Woof!
}

use std::fmt::{Debug, Display};

struct Wrapper<T> {
    value: T,
    label: String,
}

// WITHOUT where — messy with many bounds:
// impl<T: Display + Debug + PartialOrd + Clone> Wrapper<T> { ... }

// WITH where — clean, easy to read
impl<T> Wrapper<T>
where
    T: Display + Debug + PartialOrd + Clone,
{
    fn new(value: T, label: &str) -> Self {
        Self { value, label: label.to_string() }
    }

    fn display(&self) {
        println!("[{}] Display: {}  Debug: {:?}", self.label, self.value, self.value);
    }

    fn is_greater_than(&self, other: &T) -> bool {
        self.value > *other
    }
}

fn main() {
    let w1 = Wrapper::new(42_i32, "score");
    let w2 = Wrapper::new("hello", "greeting");

    w1.display(); // [score]    Display: 42    Debug: 42
    w2.display(); // [greeting] Display: hello  Debug: "hello"

    println!("42 > 10? {}", w1.is_greater_than(&10)); // true
}

// Associated type — cleaner than a type parameter when there's one natural output
trait Transformer {
    type Output;
    fn transform(&self) -> Self::Output;
}

struct Doubler(i32);
impl Transformer for Doubler {
    type Output = i32;
    fn transform(&self) -> i32 { self.0 * 2 }
}

struct Stringifier(i32);
impl Transformer for Stringifier {
    type Output = String;
    fn transform(&self) -> String { self.0.to_string() }
}

// Blanket impl — auto-implements Describe for ANYTHING that is Display
use std::fmt::Display;
trait Describe { fn describe(&self) -> String; }

impl<T: Display> Describe for T {
    fn describe(&self) -> String {
        format!("I am: {}", self)
    }
}

fn main() {
    println!("{}", Doubler(5).transform());      // 10 (i32)
    println!("{}", Stringifier(5).transform());  // "5" (String)

    println!("{}", 42_i32.describe());    // "I am: 42"  — blanket impl!
    println!("{}", "hello".describe());    // "I am: hello"
    println!("{}", 3.14_f64.describe());  // "I am: 3.14"
}