enum を使ったデータモデリング

// 支払い方法を表すenumです。
#[derive(Debug)]
enum Payment {
    Cash(f64),
    CreditCard { number: String, amount: f64 },
    CryptoCurrency { coin: String, wallet: String, amount: f64 },
}

// 状態機械パターン: 接続状態を表します。
#[derive(Debug)]
enum ConnectionState {
    Disconnected,
    Connecting { host: String, port: u16 },
    Connected { session_id: u64, latency_ms: u32 },
    Error(String),
}

// タスクの状態を表すenumです。
#[derive(Debug)]
enum TaskStatus {
    Todo,
    InProgress { started_at: String, assignee: String },
    Done { completed_at: String },
    Blocked(String),  // ブロッカーの理由
}

#[derive(Debug)]
struct Task {
    id: u32,
    title: String,
    status: TaskStatus,
}

impl Task {
    fn is_done(&self) -> bool {
        matches!(self.status, TaskStatus::Done { .. })
    }

    fn summary(&self) -> String {
        match &self.status {
            TaskStatus::Todo =>
                format!("[{}] {} - 未着手", self.id, self.title),
            TaskStatus::InProgress { assignee, .. } =>
                format!("[{}] {} - {} が対応中", self.id, self.title, assignee),
            TaskStatus::Done { completed_at } =>
                format!("[{}] {} - {} 完了", self.id, self.title, completed_at),
            TaskStatus::Blocked(reason) =>
                format!("[{}] {} - ブロック中: {}", self.id, self.title, reason),
        }
    }
}

// JSON的なデータを表すenumです（再帰的なenum）。
#[derive(Debug)]
enum JsonValue {
    Null,
    Bool(bool),
    Number(f64),
    Str(String),
    Array(Vec<JsonValue>),
}

impl JsonValue {
    fn to_string(&self) -> String {
        match self {
            JsonValue::Null => "null".to_string(),
            JsonValue::Bool(b) => b.to_string(),
            JsonValue::Number(n) => n.to_string(),
            JsonValue::Str(s) => format!("\"{}\"", s),
            JsonValue::Array(arr) => {
                let items: Vec<String> = arr.iter().map(|v| v.to_string()).collect();
                format!("[{}]", items.join(", "))
            }
        }
    }
}

fn main() {
    let tasks = vec![
        Task {
            id: 1,
            title: String::from("要件定義"),
            status: TaskStatus::Done {
                completed_at: String::from("2024-01-10"),
            },
        },
        Task {
            id: 2,
            title: String::from("設計"),
            status: TaskStatus::InProgress {
                started_at: String::from("2024-01-11"),
                assignee: String::from("Alice"),
            },
        },
        Task {
            id: 3,
            title: String::from("実装"),
            status: TaskStatus::Blocked(String::from("設計待ち")),
        },
        Task {
            id: 4,
            title: String::from("テスト"),
            status: TaskStatus::Todo,
        },
    ];

    for task in &tasks {
        println!("{}", task.summary());
    }

    let done_count = tasks.iter().filter(|t| t.is_done()).count();
    println!("完了タスク: {}/{}", done_count, tasks.len());

    // JsonValue の使用例です。
    let data = JsonValue::Array(vec![
        JsonValue::Number(1.0),
        JsonValue::Str(String::from("hello")),
        JsonValue::Bool(true),
        JsonValue::Null,
    ]);
    println!("JSON: {}", data.to_string());
}

Rustのenumを使った設計は「不正な状態を型で表現できない（Making illegal states unrepresentable）」というコンセプトを実現します。例えば『Connected』バリアントにしか『session_id』がないため、接続前に『session_id』にアクセスするコードはコンパイルエラーになります。

『matches!()』マクロはmatch式を簡潔に書けるユーティリティです。特定のバリアントかどうかをboolで確認するときに使います。

enumの基本定義は『enum / バリアント定義』を参照してください。