Rustで範囲付きバリアントを列挙型で定義する方法を徹底解説

enum Color {
    Red,
    Green,
    Blue,
}

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

fn display_color(color: Color) {
    match color {
        Color::Red => println!("Red"),
        Color::Green => println!("Green"),
        Color::Blue => println!("Blue"),
    }
}

fn print_range() {
    for i in 1..5 {
        println!("{}", i); // 出力: 1, 2, 3, 4
    }

    for i in 1..=5 {
        println!("{}", i); // 出力: 1, 2, 3, 4, 5
    }
}

enum ValueRange {
    Low,
    Medium,
    High,
}

fn categorize_value(value: u32) -> ValueRange {
    match value {
        0..=10 => ValueRange::Low,
        11..=20 => ValueRange::Medium,
        _ => ValueRange::High,
    }
}

enum ScoreCategory {
    Low,       // スコアが0～50
    Medium,    // スコアが51～80
    High,      // スコアが81～100
}

fn categorize_score(score: u32) -> ScoreCategory {
    match score {
        0..=50 => ScoreCategory::Low,
        51..=80 => ScoreCategory::Medium,
        81..=100 => ScoreCategory::High,
        _ => panic!("Score out of range!"), // 範囲外の値を防ぐ
    }
}

fn main() {
    let score = 72;
    let category = categorize_score(score);
    match category {
        ScoreCategory::Low => println!("Your score is Low."),
        ScoreCategory::Medium => println!("Your score is Medium."),
        ScoreCategory::High => println!("Your score is High."),
    }
}

enum UserCategory {
    Admin,
    Moderator,
    GeneralUser,
    Guest,
}

fn categorize_user(role: &str) -> UserCategory {
    match role {
        "admin" | "administrator" => UserCategory::Admin,
        "mod" | "moderator" => UserCategory::Moderator,
        "user" | "member" => UserCategory::GeneralUser,
        "guest" | "visitor" => UserCategory::Guest,
        _ => panic!("Invalid role!"), // 無効な文字列に対応
    }
}

fn main() {
    let role = "admin";
    let category = categorize_user(role);

    match category {
        UserCategory::Admin => println!("Welcome, Admin!"),
        UserCategory::Moderator => println!("Hello, Moderator!"),
        UserCategory::GeneralUser => println!("Hi, User!"),
        UserCategory::Guest => println!("Welcome, Guest!"),
    }
}

fn categorize_user(role: &str) -> UserCategory {
    match role.to_lowercase().as_str() {
        "admin" | "administrator" => UserCategory::Admin,
        "mod" | "moderator" => UserCategory::Moderator,
        "user" | "member" => UserCategory::GeneralUser,
        "guest" | "visitor" => UserCategory::Guest,
        _ => panic!("Invalid role!"),
    }
}

fn process_value(value: u32) {
    match value {
        0..=10 => println!("Value is in the Low range."),
        11..=20 => println!("Value is in the Medium range."),
        21..=30 => println!("Value is in the High range."),
        _ => println!("Value is out of range."),
    }
}

enum Temperature {
    Cold,
    Moderate,
    Hot,
}

fn categorize_temperature(temp: i32) -> Temperature {
    match temp {
        -30..=0 => Temperature::Cold,
        1..=20 => Temperature::Moderate,
        21..=50 => Temperature::Hot,
        _ => panic!("Temperature out of supported range!"),
    }
}

fn describe_temperature(temp: i32) {
    let category = categorize_temperature(temp);

    match category {
        Temperature::Cold => println!("It's cold outside!"),
        Temperature::Moderate => println!("The weather is moderate."),
        Temperature::Hot => println!("It's hot outside!"),
    }
}

fn main() {
    let temp = 15;
    describe_temperature(temp);
}

fn process_input(value: u32) {
    match value {
        0..=10 | 30..=40 => println!("Value is in a special range."),
        _ => println!("Value is not in a special range."),
    }
}

enum InputValidation {
    Valid(u32),
    OutOfRange(u32),
    InvalidFormat,
}

fn validate_input(input: &str) -> InputValidation {
    match input.parse::<u32>() {
        Ok(value) => match value {
            1..=100 => InputValidation::Valid(value),
            _ => InputValidation::OutOfRange(value),
        },
        Err(_) => InputValidation::InvalidFormat,
    }
}

fn process_input(input: &str) {
    match validate_input(input) {
        InputValidation::Valid(value) => println!("Valid input: {}", value),
        InputValidation::OutOfRange(value) => println!("Out of range: {}", value),
        InputValidation::InvalidFormat => println!("Invalid format: not a number"),
    }
}

fn main() {
    process_input("42");       // Valid input: 42
    process_input("150");      // Out of range: 150
    process_input("invalid");  // Invalid format: not a number
}

enum PasswordStrength {
    Weak,
    Medium,
    Strong,
    Invalid,
}

fn check_password_strength(password: &str) -> PasswordStrength {
    let length = password.len();
    match length {
        0..=5 => PasswordStrength::Weak,
        6..=10 if password.chars().any(|c| c.is_digit(10)) => PasswordStrength::Medium,
        11..=usize::MAX if password.contains('@') => PasswordStrength::Strong,
        _ => PasswordStrength::Invalid,
    }
}

enum GameDifficulty {
    Easy,
    Medium,
    Hard,
}

fn determine_difficulty(score: u32) -> GameDifficulty {
    match score {
        0..=100 => GameDifficulty::Easy,
        101..=500 => GameDifficulty::Medium,
        _ => GameDifficulty::Hard,
    }
}

fn display_difficulty(difficulty: GameDifficulty) {
    match difficulty {
        GameDifficulty::Easy => println!("Difficulty: Easy"),
        GameDifficulty::Medium => println!("Difficulty: Medium"),
        GameDifficulty::Hard => println!("Difficulty: Hard"),
    }
}

fn main() {
    let score = 250;
    let difficulty = determine_difficulty(score);
    display_difficulty(difficulty);
}

enum GameState {
    Start,
    InProgress(u32), // プレイヤーのスコア
    GameOver,
}

fn handle_game_state(state: GameState) {
    match state {
        GameState::Start => println!("Game is starting!"),
        GameState::InProgress(score) => println!("Game in progress, score: {}", score),
        GameState::GameOver => println!("Game over!"),
    }
}

fn main() {
    let state = GameState::InProgress(120);
    handle_game_state(state);
}

enum GameEvent {
    PlayerAttack(u32), // ダメージ量
    PlayerDefend,
    EnemyDefeated(String), // 敵の名前
}

fn handle_event(event: GameEvent) {
    match event {
        GameEvent::PlayerAttack(damage) => println!("Player attacked with {} damage!", damage),
        GameEvent::PlayerDefend => println!("Player defended!"),
        GameEvent::EnemyDefeated(enemy) => println!("Enemy defeated: {}", enemy),
    }
}

fn main() {
    let event = GameEvent::EnemyDefeated(String::from("Goblin"));
    handle_event(event);
}