Ders 09: Generics ve Traits

📦 Sihirli Kutu!Magic Box!

Bir kutu yap, içine ne koyarsan koy! Elmas, altın, silah... Hepsi aynı kutuya sığar!

📝 Örnek 1: Evrensel SandıkExample 1: Universal Chest

📦 sandik.berk

// T = Herhangi bir tip!
yapi Sandik[T] {
    icerik: T,
    kilit: mantıksal,
}

impl[T] Sandik[T] {
    fonksiyon yeni(esya: T) -> Sandik[T] {
        don Sandik {
            icerik: esya,
            kilit: yanlış,
        };
    }
    
    fonksiyon ac(&mut self) -> &T {
        self.kilit = yanlış;
        yazdir("🔓 Sandık açıldı!");
        don &self.icerik;
    }
    
    fonksiyon kilitle(&mut self) {
        self.kilit = doğru;
        yazdir("🔒 Sandık kilitlendi!");
    }
}

fonksiyon ana() {
    // Elmas sandığı
    değişken mut elmas_sandigi = Sandik::yeni("💎 Efsanevi Elmas");
    yazdir("Sandık içeriği: {}", elmas_sandigi.ac());
    
    // Altın sandığı
    değişken mut altin_sandigi = Sandik::yeni(1000);
    yazdir("Altın miktarı: {} 💰", altin_sandigi.ac());
    
    // Silah sandığı
    değişken mut silah_sandigi = Sandik::yeni("⚔️ Ejder Kılıcı");
    yazdir("Silah: {}", silah_sandigi.ac());
}

📝 Örnek 2: Yetenek SistemiExample 2: Ability System

⚡ yetenekler.berk

// Trait = Yetenek! Bunu yapabilen herkes...
ozellik Saldirabilir {
    fonksiyon saldir(&self) -> tamsayı;
    fonksiyon saldir_ismi(&self) -> metin;
}

yapi Savasci {
    guc: tamsayı,
}

yapi Buyucu {
    buyu_gucu: tamsayı,
}

// Savaşçı saldırabilir
impl Saldirabilir icin Savasci {
    fonksiyon saldir(&self) -> tamsayı {
        don self.guc * 2;
    }
    fonksiyon saldir_ismi(&self) -> metin {
        don "⚔️ Kılıç Darbesi";
    }
}

// Büyücü de saldırabilir
impl Saldirabilir icin Buyucu {
    fonksiyon saldir(&self) -> tamsayı {
        don self.buyu_gucu * 3;
    }
    fonksiyon saldir_ismi(&self) -> metin {
        don "🔥 Ateş Topu";
    }
}

// Her saldırabilene çalışır!
fonksiyon savas_yap[T: Saldirabilir](karakter: &T) {
    yazdir("{}: {} hasar!", karakter.saldir_ismi(), karakter.saldir());
}

fonksiyon ana() {
    değişken savasci = Savasci { guc: 50 };
    değişken buyucu = Buyucu { buyu_gucu: 40 };
    
    savas_yap(&savasci);  // ⚔️ Kılıç Darbesi: 100 hasar!
    savas_yap(&buyucu);   // 🔥 Ateş Topu: 120 hasar!
}

📖 Generics Nedir?What are Generics?

Generics, farklı tipler için aynı kodu kullanmanı sağlar. Kod tekrarını önler!

📝 Örnek 1: Generic Veri YapılarıExample 1: Generic Data Structures

📊 structures.berk

// Generic stack
yapi Yigin[T] {
    elemanlar: Vektor[T],
}

impl[T] Yigin[T] {
    fonksiyon yeni() -> Yigin[T] {
        Yigin { elemanlar: Vektor::yeni() }
    }
    
    fonksiyon ekle(&mut self, eleman: T) {
        self.elemanlar.ekle(eleman);
    }
    
    fonksiyon cikar(&mut self) -> Belki[T] {
        self.elemanlar.son_cikar()
    }
    
    fonksiyon bos_mu(&self) -> mantıksal {
        self.elemanlar.bos_mu()
    }
    
    fonksiyon boyut(&self) -> tamsayı {
        self.elemanlar.uzunluk()
    }
}

fonksiyon ana() {
    // Sayı yığını
    değişken mut sayilar = Yigin::yeni();
    sayilar.ekle(1);
    sayilar.ekle(2);
    sayilar.ekle(3);
    
    iken !sayilar.bos_mu() yap
        yazdir("Çıkan: {:?}", sayilar.cikar());
    son
    
    // Metin yığını - aynı kod!
    değişken mut metinler = Yigin::yeni();
    metinler.ekle("Merhaba");
    metinler.ekle("Dünya");
    
    yazdir("Metin: {:?}", metinler.cikar());
}

📝 Örnek 2: Traits ile PolimorfizmExample 2: Polymorphism with Traits

🎨 shapes.berk

// Interface tanımla
trait Drawable {
    function draw(&self);
    function area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Drawable for Circle {
    function draw(&self) {
        print!("⭕ Circle (r={})", self.radius);
    }
    function area(&self) -> f64 {
        3.14159 * self.radius * self.radius
    }
}

impl Drawable for Rectangle {
    function draw(&self) {
        print!("▭ Rectangle ({}x{})", self.width, self.height);
    }
    function area(&self) -> f64 {
        self.width * self.height
    }
}

// Generic fonksiyon trait bound ile
function print_area(shape: &T) {
    shape.draw();
    print!("  Area: {:.2}", shape.area());
}

function main() {
    let circle = Circle { radius: 5.0 };
    let rect = Rectangle { width: 4.0, height: 6.0 };
    
    print_area(&circle);
    print_area(&rect);
    
    // Total area
    let shapes: Vec<&dyn Drawable> = vec![&circle, &rect];
    let total: f64 = shapes.iter().map(|s| s.area()).sum();
    print!("\nTotal area: {:.2}", total);
}

🎯 Advanced GenericsAdvanced Generics

Associated types
Trait objects (dyn)
Where clauses
Const generics

📝 Örnek 1: Iterator PatternExample 1: Iterator Pattern

BERK (Iterator)

// Associated type kullanımı
trait Iterator {
    type Item;  // Associated type
    
    function next(&mut self) -> Option;
    
    // Default implementations
    function map(self, f: F) -> Map
    where
        Self: Sized,
        F: FnMut(Self::Item) -> B,
    {
        Map { iter: self, f }
    }
    
    function filter(self, predicate: P) -> Filter
    where
        Self: Sized,
        P: FnMut(&Self::Item) -> bool,
    {
        Filter { iter: self, predicate }
    }
    
    function collect(self) -> B
    where
        Self: Sized,
        B: FromIterator,
    {
        FromIterator::from_iter(self)
    }
}

// Custom iterator
struct Counter {
    current: u32,
    max: u32,
}

impl Iterator for Counter {
    type Item = u32;
    
    function next(&mut self) -> Option {
        if self.current < self.max {
            let val = self.current;
            self.current += 1;
            Some(val)
        } else {
            None
        }
    }
}

function main() {
    let counter = Counter { current: 0, max: 5 };
    
    let result: Vec = counter
        .map(|x| x * 2)
        .filter(|&x| x > 2)
        .collect();
    
    print!("Result: {:?}", result);  // [4, 6, 8]
}

📝 Örnek 2: Type-Level ProgrammingExample 2: Type-Level Programming

BERK (Type-Level)

// Const generics for fixed-size arrays struct Matrix { data: [[T; COLS]; ROWS], } impl Matrix { function new() -> Self { Matrix { data: [[T::default(); COLS]; ROWS], } } function get(&self, row: usize, col: usize) -> T { self.data[row][col] } function set(&mut self, row: usize, col: usize, value: T) { self.data[row][col] = value; } } // Matrix multiplication with compile-time dimension check impl Matrix where T: Default + Copy + std::ops::Add + std::ops::Mul, { function multiply( &self, other: &Matrix, ) -> Matrix { let mut result = Matrix::new(); for i in 0..M { for j in 0..P { let mut sum = T::default(); for k in 0..N { sum = sum + self.data[i][k] * other.data[k][j]; } result.data[i][j] = sum; } } result } } // Phantom types for type-state pattern use std::marker::PhantomData; struct Locked; struct Unlocked; struct Door { _state: PhantomData, } impl Door { function unlock(self) -> Door { print!("Door unlocked"); Door { _state: PhantomData } } } impl Door { function open(&self) { print!("Door opened"); } function lock(self) -> Door { print!("Door locked"); Door { _state: PhantomData } } } function main() { // Matrix example let mut m1: Matrix = Matrix::new(); let m2: Matrix = Matrix::new(); let _result: Matrix = m1.multiply(&m2); // Compile-time checked! // Type-state pattern let door: Door = Door { _state: PhantomData }; let door = door.unlock(); // Now Door door.open(); // OK: open() only on Unlocked // door.unlock(); // Compile error: no unlock() on Unlocked }

📌 ÖzetSummary

<T> ile generic tip parametresi tanımlanır<T> defines generic type parameter

trait/ozellik ile davranış tanımlanırtrait/ozellik defines behavior

T: Trait ile tip kısıtlaması yapılırT: Trait constrains the type