Ders 06: Enum ve Match

🎮 Oyunda Seçimler!Choices in Games!

Enum = Sabit seçenekler listesi! RPG'deki karakter sınıfları gibi.

📝 Örnek 1: Karakter SınıfıExample 1: Character Class

⚔️ siniflar.berk

// Karakter sınıfları - sadece bu 4'ü olabilir!
enum KarakterSinifi {
    Savasci,    // ⚔️
    Buyucu,     // 🔮
    Okcu,       // 🏹
    Hirsiz,     // 🗡️
}

fonksiyon sinif_ozellikleri(sinif: KarakterSinifi) {
    esle sinif yap
        KarakterSinifi::Savasci => {
            yazdir("⚔️ SAVAŞÇI");
            yazdir("  HP: 150 | ATK: 40 | DEF: 30");
            yazdir("  Özel: Kalkan Savunması");
        },
        KarakterSinifi::Buyucu => {
            yazdir("🔮 BÜYÜCÜ");
            yazdir("  HP: 80 | ATK: 60 | DEF: 10");
            yazdir("  Özel: Ateş Topu");
        },
        KarakterSinifi::Okcu => {
            yazdir("🏹 OKÇU");
            yazdir("  HP: 100 | ATK: 50 | DEF: 15");
            yazdir("  Özel: Kritik Atış");
        },
        KarakterSinifi::Hirsiz => {
            yazdir("🗡️ HIRSIZ");
            yazdir("  HP: 90 | ATK: 45 | DEF: 20");
            yazdir("  Özel: Gizlenme");
        },
    son
}

fonksiyon ana() {
    yazdir("🎮 RPG KARAKTER SEÇİMİ\n");
    
    değişken secim = KarakterSinifi::Buyucu;
    sinif_ozellikleri(secim);
}

📝 Örnek 2: Oyun DurumlarıExample 2: Game States

🎲 oyun.berk

enum OyunDurumu {
    Menu,
    Oynuyor,
    Durakladi,
    BittiKazandi,
    BittiKaybetti,
}

fonksiyon durum_goster(durum: OyunDurumu) {
    esle durum yap
        OyunDurumu::Menu => yazdir("🏠 ANA MENÜ"),
        OyunDurumu::Oynuyor => yazdir("🎮 OYUN DEVAM EDİYOR..."),
        OyunDurumu::Durakladi => yazdir("⏸️ DURAKLATILDI"),
        OyunDurumu::BittiKazandi => {
            yazdir("🏆 TEBRİKLER!");
            yazdir("🎉 KAZANDIN!");
        },
        OyunDurumu::BittiKaybetti => {
            yazdir("💀 GAME OVER");
            yazdir("😢 Kaybettin...");
        },
    son
}

fonksiyon ana() {
    değişken mut durum = OyunDurumu::Menu;
    durum_goster(durum);
    
    durum = OyunDurumu::Oynuyor;
    durum_goster(durum);
    
    durum = OyunDurumu::BittiKazandi;
    durum_goster(durum);
}

📖 Enum Nedir?What is Enum?

Enum, bir değişkenin sadece belirli değerlerden birini alabileceğini tanımlar.

📝 Örnek 1: Trafik IşığıExample 1: Traffic Light

🚦 trafik.berk

enum TrafikIsigi {
    Kirmizi,
    Sari,
    Yesil,
}

fonksiyon bekle_suresi(isik: TrafikIsigi) -> tamsayı {
    esle isik yap
        TrafikIsigi::Kirmizi => 30,
        TrafikIsigi::Sari => 5,
        TrafikIsigi::Yesil => 25,
    son
}

fonksiyon mesaj(isik: TrafikIsigi) -> metin {
    esle isik yap
        TrafikIsigi::Kirmizi => "🛑 DUR!",
        TrafikIsigi::Sari => "⚠️ HAZIRLAN",
        TrafikIsigi::Yesil => "✅ GEÇ",
    son
}

fonksiyon ana() {
    değişken isiklar = [
        TrafikIsigi::Yesil,
        TrafikIsigi::Sari,
        TrafikIsigi::Kirmizi,
    ];
    
    icin isik in isiklar {
        yazdir("{}", mesaj(isik));
        yazdir("  Süre: {} saniye\n", bekle_suresi(isik));
    }
}

📝 Örnek 2: HTTP StatusExample 2: HTTP Status

🌐 http.berk

enum HttpStatus {
    Ok(string),           // 200 + body
    NotFound,             // 404
    BadRequest(string),   // 400 + error message
    ServerError,          // 500
}

function handle_response(status: HttpStatus) {
    match status {
        HttpStatus::Ok(body) => {
            print("✅ 200 OK");
            print("Body: {}", body);
        },
        HttpStatus::NotFound => {
            print("❌ 404 Not Found");
        },
        HttpStatus::BadRequest(msg) => {
            print("⚠️ 400 Bad Request: {}", msg);
        },
        HttpStatus::ServerError => {
            print("🔥 500 Internal Server Error");
        },
    }
}

function main() {
    let response1 = HttpStatus::Ok("Hello, World!".to_string());
    let response2 = HttpStatus::NotFound;
    let response3 = HttpStatus::BadRequest("Invalid JSON".to_string());
    
    handle_response(response1);
    print("");
    handle_response(response2);
    print("");
    handle_response(response3);
}

🎯 Algebraic Data TypesAlgebraic Data Types

Sum types (enum variants)
Product types (structs)
Pattern matching exhaustiveness
Option ve Result monads

📝 Örnek 1: Expression EvaluatorExample 1: Expression Evaluator

BERK (AST)

// AST for arithmetic expressions
enum Expr {
    Literal(i64),
    Add(Box, Box),
    Sub(Box, Box),
    Mul(Box, Box),
    Div(Box, Box),
}

impl Expr {
    function eval(&self) -> Result {
        match self {
            Expr::Literal(n) => Ok(*n),
            Expr::Add(l, r) => Ok(l.eval()? + r.eval()?),
            Expr::Sub(l, r) => Ok(l.eval()? - r.eval()?),
            Expr::Mul(l, r) => Ok(l.eval()? * r.eval()?),
            Expr::Div(l, r) => {
                let divisor = r.eval()?;
                if divisor == 0 {
                    Err("Division by zero")
                } else {
                    Ok(l.eval()? / divisor)
                }
            }
        }
    }
    
    function display(&self) -> String {
        match self {
            Expr::Literal(n) => n.to_string(),
            Expr::Add(l, r) => format!("({} + {})", l.display(), r.display()),
            Expr::Sub(l, r) => format!("({} - {})", l.display(), r.display()),
            Expr::Mul(l, r) => format!("({} * {})", l.display(), r.display()),
            Expr::Div(l, r) => format!("({} / {})", l.display(), r.display()),
        }
    }
}

function main() {
    // (2 + 3) * 4 = 20
    let expr = Expr::Mul(
        Box::new(Expr::Add(
            Box::new(Expr::Literal(2)),
            Box::new(Expr::Literal(3)),
        )),
        Box::new(Expr::Literal(4)),
    );
    
    print("Expression: {}", expr.display());
    match expr.eval() {
        Ok(result) => print("Result: {}", result),
        Err(e) => print("Error: {}", e),
    }
}

📝 Örnek 2: Error HandlingExample 2: Error Handling

BERK (Result)

// Custom error type
enum DatabaseError {
    ConnectionFailed(String),
    QueryFailed { query: String, reason: String },
    NotFound { table: String, id: u64 },
    PermissionDenied,
}

impl DatabaseError {
    function message(&self) -> String {
        match self {
            DatabaseError::ConnectionFailed(host) => 
                format!("Failed to connect to {}", host),
            DatabaseError::QueryFailed { query, reason } => 
                format!("Query '{}' failed: {}", query, reason),
            DatabaseError::NotFound { table, id } => 
                format!("Record {} not found in {}", id, table),
            DatabaseError::PermissionDenied => 
                "Permission denied".to_string(),
        }
    }
}

type DbResult = Result;

struct User {
    id: u64,
    name: String,
}

function find_user(id: u64) -> DbResult {
    // Simulated lookup
    if id == 0 {
        return Err(DatabaseError::NotFound { 
            table: "users".to_string(), 
            id 
        });
    }
    Ok(User { id, name: "Alice".to_string() })
}

function main() {
    // Proper error handling
    match find_user(1) {
        Ok(user) => print("Found: {} (ID: {})", user.name, user.id),
        Err(e) => print("Error: {}", e.message()),
    }
    
    // Using ? operator for propagation
    let user_name = find_user(0)
        .map(|u| u.name)
        .unwrap_or_else(|e| format!("", e.message()));
    
    print("Result: {}", user_name);
}

📌 ÖzetSummary

enum sabit seçenekler tanımlarenum defines fixed options
esle/match ile pattern matching yapılıresle/match for pattern matching
Enum variants veri taşıyabilirEnum variants can carry data