枚举 #

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn main() {
    let dir = Direction::Up;
    
    match dir {
        Direction::Up => println!("向上"),
        Direction::Down => println!("向下"),
        Direction::Left => println!("向左"),
        Direction::Right => println!("向右"),
    }
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::Move { x: 10, y: 20 };
    
    match msg {
        Message::Quit => println!("退出"),
        Message::Move { x, y } => println!("移动到 ({}, {})", x, y),
        Message::Write(text) => println!("文本: {}", text),
        Message::ChangeColor(r, g, b) => println!("颜色: ({}, {}, {})", r, g, b),
    }
}

enum Option<T> {
    Some(T),
    None,
}

fn main() {
    let some_number = Some(5);
    let some_string = Some("hello");
    let absent_number: Option<i32> = None;
    
    match some_number {
        Some(n) => println!("值: {}", n),
        None => println!("无值"),
    }
}

fn main() {
    let some_value = Some(5);
    
    if let Some(n) = some_value {
        println!("值: {}", n);
    }
}

fn main() {
    let x = Some(5);
    
    // unwrap: 获取值，None 会 panic
    println!("unwrap: {}", x.unwrap());
    
    // unwrap_or: 提供默认值
    let y: Option<i32> = None;
    println!("unwrap_or: {}", y.unwrap_or(0));
    
    // map: 转换值
    let doubled = x.map(|n| n * 2);
    println!("map: {:?}", doubled);
    
    // and_then: 链式操作
    let result = x.and_then(|n| Some(n + 1));
    println!("and_then: {:?}", result);
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("除零错误"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(result) => println!("结果: {}", result),
        Err(e) => println!("错误: {}", e),
    }
}

fn multiply_and_divide(a: i32, b: i32, c: i32) -> Result<i32, String> {
    let quotient = divide(a, b)?;
    Ok(quotient * c)
}

fn main() {
    match multiply_and_divide(10, 2, 3) {
        Ok(result) => println!("结果: {}", result),
        Err(e) => println!("错误: {}", e),
    }
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

impl Message {
    fn call(&self) {
        match self {
            Message::Quit => println!("退出"),
            Message::Move { x, y } => println!("移动 ({}, {})", x, y),
            Message::Write(text) => println!("文本: {}", text),
        }
    }
}

fn main() {
    let msg = Message::Write(String::from("hello"));
    msg.call();
}

enum Status {
    Pending,
    InProgress,
    Completed,
}

impl Status {
    fn default() -> Self {
        Status::Pending
    }
}

fn main() {
    let status = Status::default();
}

#[derive(Debug)]
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

impl TrafficLight {
    fn next(&self) -> Self {
        match self {
            TrafficLight::Red => TrafficLight::Green,
            TrafficLight::Green => TrafficLight::Yellow,
            TrafficLight::Yellow => TrafficLight::Red,
        }
    }
    
    fn duration(&self) -> u32 {
        match self {
            TrafficLight::Red => 60,
            TrafficLight::Yellow => 5,
            TrafficLight::Green => 45,
        }
    }
}

fn main() {
    let mut light = TrafficLight::Red;
    
    for _ in 0..5 {
        println!("{:?} - {}秒", light, light.duration());
        light = light.next();
    }
}

enum Expr {
    Number(i32),
    Add(Box<Expr>, Box<Expr>),
    Multiply(Box<Expr>, Box<Expr>),
}

impl Expr {
    fn evaluate(&self) -> i32 {
        match self {
            Expr::Number(n) => *n,
            Expr::Add(a, b) => a.evaluate() + b.evaluate(),
            Expr::Multiply(a, b) => a.evaluate() * b.evaluate(),
        }
    }
}

fn main() {
    // (2 + 3) * 4
    let expr = Expr::Multiply(
        Box::new(Expr::Add(
            Box::new(Expr::Number(2)),
            Box::new(Expr::Number(3)),
        )),
        Box::new(Expr::Number(4)),
    );
    
    println!("结果: {}", expr.evaluate());
}