Types and Traits

// Struct — named fields of different types
#[derive(Debug)]   // auto-implement Debug for println!("{:?}", ...)
struct User {
    name:    String,
    email:   String,
    age:     u32,
    active:  bool,
}

impl User {
    // Associated function (like a static method) — constructor pattern
    fn new(name: &str, email: &str, age: u32) -> Self {
        User {
            name:   name.to_string(),
            email:  email.to_string(),
            age,              // shorthand when field = variable name
            active: true,
        }
    }

    // Method — takes &self (immutable borrow of the instance)
    fn greeting(&self) -> String {
        format!("Hello, {}!", self.name)
    }

    // Mutable method — takes &mut self
    fn deactivate(&mut self) {
        self.active = false;
    }
}

// Enum — a type that can be one of several variants
#[derive(Debug)]
enum Direction { North, South, East, West }

// Enum with data — each variant can hold different types
#[derive(Debug)]
enum Message {
    Quit,                          // no data
    Move { x: i32, y: i32 },      // struct-like
    Write(String),                 // tuple-like
    ChangeColor(u8, u8, u8),       // tuple with three values
}

fn main() {
    let mut user = User::new("Priya", "priya@example.com", 28);
    println!("{}", user.greeting());   // "Hello, Priya!"
    user.deactivate();
    println!("{:#?}", user);           // pretty debug print

    let msg = Message::Move { x: 10, y: 20 };
    println!("{:?}", msg);
}

fn describe_message(msg: &Message) {
    match msg {
        Message::Quit              => println!("Quit"),
        Message::Move { x, y }    => println!("Move to ({x}, {y})"),
        Message::Write(text)       => println!("Write: {text}"),
        Message::ChangeColor(r,g,b) => println!("Color: #{r:02x}{g:02x}{b:02x}"),
    }
    // match must be exhaustive — all variants covered or use _ wildcard
}

// Option<T> — the Rust null replacement
// Option<T> is either Some(value) or None — no null pointer dereferences
fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 { None } else { Some(a / b) }
}

fn main() {
    let result = divide(10.0, 2.0);
    match result {
        Some(v) => println!("Result: {v}"),
        None    => println!("Division by zero"),
    }

    // if let — pattern match for one variant
    if let Some(v) = divide(10.0, 3.0) {
        println!("Got: {v:.2}");
    }

    // unwrap_or — default value if None
    let v = divide(10.0, 0.0).unwrap_or(0.0);

    // ? operator — propagate None (or Err) upward
    // fn double_divide(a: f64, b: f64) -> Option<f64> {
    //     let first = divide(a, b)?;   // returns None if divide returns None
    //     Some(first * 2.0)
    // }
}

// Trait — defines shared behaviour (like an interface)
trait Animal {
    fn name(&self) -> &str;
    fn sound(&self) -> String;

    // Default implementation — can be overridden
    fn describe(&self) -> String {
        format!("{} says {}", self.name(), self.sound())
    }
}

struct Dog { name: String }
struct Cat { name: String }

impl Animal for Dog {
    fn name(&self) -> &str { &self.name }
    fn sound(&self) -> String { "Woof".to_string() }
}

impl Animal for Cat {
    fn name(&self) -> &str { &self.name }
    fn sound(&self) -> String { "Meow".to_string() }
    // Override default
    fn describe(&self) -> String {
        format!("{} says {} (quietly)", self.name(), self.sound())
    }
}

// Trait as a function parameter — accepts any type implementing Animal
fn make_noise(animal: &impl Animal) {
    println!("{}", animal.describe());
}

// Generic syntax — equivalent to above
fn make_noise_generic<T: Animal>(animal: &T) {
    println!("{}", animal.describe());
}

fn main() {
    let dog = Dog { name: "Rex".to_string() };
    let cat = Cat { name: "Whiskers".to_string() };
    make_noise(&dog);   // "Rex says Woof"
    make_noise(&cat);   // "Whiskers says Meow (quietly)"
}