Structs, Enums & Matching

struct User {
    name: String,
    email: String,
    active: bool,
    logins: u32,
}

fn new_user(name: String, email: String) -> User {
    User {
        name,            // field init shorthand: same as name: name
        email,
        active: true,
        logins: 0,
    }
}

fn main() {
    let mut ada = new_user(String::from("ada"), String::from("[email protected]"));
    ada.logins += 1;                  // the whole instance is mut, never one field
    println!("{} <{}> active={} logins={}", ada.name, ada.email, ada.active, ada.logins);

    // struct update syntax: take the rest of the fields from another value
    let bot = User {
        name: String::from("deploy-bot"),
        email: String::from("[email protected]"),
        ..ada
    };
    println!("{} active={} logins={}", bot.name, bot.active, bot.logins);
    println!("{} still usable", ada.name);
}

struct Meters(f64);
struct Feet(f64);
struct Rgb(u8, u8, u8);
struct Healthy;                       // unit struct: no fields

fn to_feet(m: Meters) -> Feet {
    Feet(m.0 * 3.28084)
}

fn main() {
    let height = Meters(2.0);
    let f = to_feet(height);
    println!("{:.2} ft", f.0);

    let orange = Rgb(255, 165, 0);
    let Rgb(r, g, b) = orange;         // destructure a tuple struct
    println!("#{:02x}{:02x}{:02x}", r, g, b);

    let _status = Healthy;
    println!("size of Healthy: {} bytes", std::mem::size_of::<Healthy>());
}

struct Account {
    owner: String,
    balance: i64,
}

impl Account {
    fn new(owner: &str) -> Self {            // associated function; Self = Account
        Self { owner: owner.to_string(), balance: 0 }
    }

    fn balance(&self) -> i64 {               // read
        self.balance
    }

    fn deposit(&mut self, amount: i64) {     // modify
        self.balance += amount;
    }

    fn close(self) -> String {               // consume
        format!("closed {} with {}", self.owner, self.balance)
    }
}

fn main() {
    let mut acc = Account::new("ada");
    acc.deposit(150);
    acc.deposit(50);
    println!("balance {}", acc.balance());
    let receipt = acc.close();                // acc is moved into close()
    println!("{receipt}");
}

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

#[derive(Debug, Clone, PartialEq)]
struct Route {
    name: String,
    stops: Vec<Point>,
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = a;                              // Copy: a is still usable
    println!("{:?} == {:?}: {}", a, b, a == b);

    let r1 = Route { name: String::from("loop"), stops: vec![a, Point { x: 5, y: 5 }] };
    let mut r2 = r1.clone();                // deep copy, including the Vec
    r2.stops.push(Point { x: 0, y: 0 });
    println!("equal after push? {}", r1 == r2);
    println!("{:#?}", r1);
}

#[derive(Debug)]
enum Shape {
    Circle { radius: f64 },
    Rect { w: f64, h: f64 },
    Triangle(f64, f64, f64),             // tuple-like variant
    Dot,                                 // no data
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle { radius } => 3.14159 * radius * radius,
            Shape::Rect { w, h } => w * h,
            Shape::Triangle(a, b, c) => {
                let s = (a + b + c) / 2.0;                   // Heron's formula
                (s * (s - a) * (s - b) * (s - c)).sqrt()
            }
            Shape::Dot => 0.0,
        }
    }
}

fn main() {
    let shapes = vec![
        Shape::Circle { radius: 1.0 },
        Shape::Rect { w: 3.0, h: 4.0 },
        Shape::Triangle(3.0, 4.0, 5.0),
        Shape::Dot,
    ];
    for s in &shapes {
        println!("{:?} -> {:.2}", s, s.area());
    }
}

fn find_index(items: &[&str], target: &str) -> Option<usize> {
    for (i, item) in items.iter().enumerate() {
        if *item == target {
            return Some(i);
        }
    }
    None
}

fn main() {
    let menu = ["tea", "coffee", "juice"];

    match find_index(&menu, "coffee") {
        Some(i) => println!("coffee is item {i}"),
        None => println!("no coffee"),
    }

    let missing = find_index(&menu, "cocoa");
    println!("{:?} {:?}", missing, find_index(&menu, "tea"));
    println!("or default: {}", missing.unwrap_or(99));
    println!("is_some: {}", missing.is_some());
    println!("doubled: {:?}", find_index(&menu, "juice").map(|i| i * 2));
}

struct Point {
    x: i32,
    y: i32,
}

enum Event {
    Click { at: Point, button: u8 },
    Key(char),
    Scroll(i32),
    Resize(u32, u32),
}

fn describe(e: &Event) -> String {
    match e {
        Event::Click { at: Point { x: 0, y: 0 }, .. } => String::from("click at origin"),
        Event::Click { at, button: 1 } => format!("left click at ({}, {})", at.x, at.y),
        Event::Click { button, .. } => format!("button {button} click"),
        Event::Key(c) if c.is_ascii_digit() => format!("digit {c}"),     // guard
        Event::Key(c) => format!("key {c}"),
        Event::Scroll(n @ 1..=10) => format!("small scroll {n}"),        // @ binding
        Event::Scroll(n) => format!("scroll {n}"),
        Event::Resize(w, h) if w == h => format!("square {w}"),
        Event::Resize(w, h) => format!("{w}x{h}"),
    }
}

fn main() {
    let events = [
        Event::Click { at: Point { x: 0, y: 0 }, button: 1 },
        Event::Click { at: Point { x: 4, y: 7 }, button: 1 },
        Event::Click { at: Point { x: 4, y: 7 }, button: 3 },
        Event::Key('7'),
        Event::Key('q'),
        Event::Scroll(3),
        Event::Scroll(-40),
        Event::Resize(800, 800),
        Event::Resize(1920, 1080),
    ];
    for e in &events {
        println!("{}", describe(e));
    }
}

fn parse_port(text: &str) -> u16 {
    let Ok(port) = text.trim().parse::<u16>() else {
        return 8080;                           // must diverge
    };
    port                                        // port is in scope from here on
}

fn main() {
    let config_port: Option<u16> = Some(3000);
    if let Some(p) = config_port {
        println!("configured port {p}");
    }

    let theme: Option<&str> = None;
    if let Some(t) = theme {
        println!("theme {t}");
    } else {
        println!("default theme");
    }

    println!("{} {}", parse_port("443"), parse_port("not a port"));

    let mut stack = vec![1, 2, 3];
    while let Some(top) = stack.pop() {        // pop() returns Option<i32>
        print!("{top} ");
    }
    println!("| empty: {}", stack.is_empty());
}