여러 가능성을 하나로: 열거형

동작하는 코드

신호등을 생각해보세요. 빨강, 노랑, 초록 중 하나의 상태만 가능하죠? 이런 "여러 가능성 중 하나"를 표현하는 게 열거형(enum) 이에요.

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

fn action(light: &TrafficLight) {
    match light {
        TrafficLight::Red => println!("정지!"),
        TrafficLight::Yellow => println!("주의!"),
        TrafficLight::Green => println!("출발!"),
    }
}

fn main() {
    let light = TrafficLight::Red;
    action(&light);
    println!("현재 신호: {:?}", light);
}

match는 값을 보고 어떤 variant인지에 따라 다른 동작을 실행해요. 분류 기계라고 생각하면 돼요 — 값을 넣으면 모양에 따라 다른 칸으로 보내는 기계예요.

직접 수정하기

1. light를 TrafficLight::Green으로 바꿔보세요. 출력이 달라지나요?
2. match에서 TrafficLight::Yellow 줄을 삭제해보세요. 어떤 에러가 나나요?

"왜?" — 데이터를 가진 열거형

열거형의 진짜 힘은 각 variant에 데이터를 포함할 수 있다는 거예요.

#[derive(Debug)]
enum Shape {
    Circle(f64),              // 반지름
    Rectangle(f64, f64),      // 가로, 세로
    Triangle(f64, f64, f64),  // 세 변의 길이
}

fn describe(shape: &Shape) {
    match shape {
        Shape::Circle(r) => {
            println!("원: 반지름 {r}");
        }
        Shape::Rectangle(w, h) => {
            println!("직사각형: {w} x {h}");
        }
        Shape::Triangle(a, b, c) => {
            println!("삼각형: 변 {a}, {b}, {c}");
        }
    }
}

fn main() {
    let shapes = vec![
        Shape::Circle(5.0),
        Shape::Rectangle(10.0, 3.0),
        Shape::Triangle(3.0, 4.0, 5.0),
    ];

    for s in &shapes {
        describe(s);
    }
}

Shape 하나의 타입으로 원, 직사각형, 삼각형을 모두 담을 수 있어요. 구조체만으로는 이런 표현이 어려워요.

match는 빠짐없이 처리해야 해요

match의 가장 중요한 특징은 모든 가능성을 빠짐없이(exhaustive) 처리해야 한다는 거예요.

error[E0004]: non-exhaustive patterns: `Shape::Triangle(_, _, _)`
              not covered

모든 경우를 일일이 처리하기 번거로울 때는 _로 나머지를 묶을 수 있어요.

fn is_circle(shape: &Shape) -> bool {
    match shape {
        Shape::Circle(_) => true,
        _ => false,  // 나머지는 전부 false
    }
}

if let — 하나만 확인할 때

하나의 variant만 확인하고 나머지는 무시하고 싶을 때는 if let이 깔끔해요.

fn main() {
    let shape = Shape::Circle(5.0);

    // match로 쓰면
    match &shape {
        Shape::Circle(r) => println!("반지름: {r}"),
        _ => {}
    }

    // if let으로 쓰면 — 훨씬 깔끔!
    if let Shape::Circle(r) = &shape {
        println!("반지름: {r}");
    }
}

열거형에도 메서드를 추가할 수 있어요

구조체처럼 impl 블록으로 메서드를 넣을 수 있어요.

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(r) => std::f64::consts::PI * r * r,
            Shape::Rectangle(w, h) => w * h,
            Shape::Triangle(a, b, c) => {
                // 헤론의 공식
                let s = (a + b + c) / 2.0;
                (s * (s - a) * (s - b) * (s - c)).sqrt()
            }
        }
    }
}

enum Option<T> {
    Some(T),   // 값이 있음
    None,      // 값이 없음
}

fn main() {
    let numbers = vec![1, 2, 3];
    let first = numbers.first();  // Option<&i32>

    match first {
        Some(n) => println!("첫 번째: {n}"),
        None => println!("비어있어요"),
    }
}

#[derive(Debug)]
enum Coin {
    Ten,        // 10원
    Fifty,      // 50원
    Hundred,    // 100원
    FiveHundred,// 500원
}

impl Coin {
    fn value(&self) -> i32 {
        // 여기를 완성하세요
        // match를 사용해서 각 variant에 맞는 금액을 반환
    }
}

fn main() {
    let coins = vec![
        Coin::Hundred,
        Coin::FiveHundred,
        Coin::Fifty,
    ];

    let total: i32 = coins.iter().map(|c| c.value()).sum();
    println!("총액: {total}원");
    // 출력: 총액: 650원
}

#[derive(Debug)]
enum Message {
    Quit,
    Echo(String),
    Move { x: i32, y: i32 },
}

fn process(msg: &Message) {
    // 여기를 완성하세요
    // Quit -> "종료합니다" 출력
    // Echo(text) -> text 내용을 출력
    // Move { x, y } -> "({x}, {y})로 이동" 출력
}

fn main() {
    let messages = vec![
        Message::Echo(String::from("안녕!")),
        Message::Move { x: 10, y: 20 },
        Message::Quit,
    ];

    for msg in &messages {
        process(msg);
    }
}

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

fn main() {
    let dir = Direction::Up;
    let msg = match dir {
        Direction::Up => "위",
        Direction::Down => "아래",
        _ => "옆",
    };
    println!("{msg}");
}