الاستخدام المتقدم للسمات: الأنواع المرتبطة

ما الأنواع المرتبطة؟

لماذا نستخدم الأنواع المرتبطة؟

تعريف سمة بنوع مرتبط

trait Container {
    type Item; // Associated type declaration
    fn add(&mut self, item: Self::Item);
    fn contains(&self, item: &Self::Item) -> bool;
}

تنفيذ السمة

trait Container {
    type Item;
    fn add(&mut self, item: Self::Item);
    fn contains(&self, item: &Self::Item) -> bool;
}

struct MyVec {
    elements: Vec<i32>,
}

impl Container for MyVec {
    type Item = i32; // Specify the concrete type for Item

    fn add(&mut self, item: Self::Item) {
        self.elements.push(item);
    }

    fn contains(&self, item: &Self::Item) -> bool {
        self.elements.contains(item)
    }
}

fn main() {
    let mut my_vec = MyVec { elements: vec![] };
    my_vec.add(10);
    my_vec.add(20);
    println!("Contains 10: {}", my_vec.contains(&10));
    println!("Contains 30: {}", my_vec.contains(&30));
}

الأنواع المرتبطة مقابل الأنواع العامة

مثال من العالم الحقيقي: سمة `Iterator`

// Simplified Iterator trait
trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

struct Counter {
    count: u32,
}

impl Iterator for Counter {
    type Item = u32; // This iterator yields u32 values

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let mut counter = Counter { count: 0 };
    // Using the iterator directly
    while let Some(num) = counter.next() {
        println!("Current count: {}", num);
    }
}

تقييد الأنواع المرتبطة

trait PrintableContainer {
    type Item: std::fmt::Debug; // Item must implement Debug
    fn add(&mut self, item: Self::Item);
    fn print_all(&self);
}

struct DebugVec {
    elements: Vec<String>,
}

impl PrintableContainer for DebugVec {
    type Item = String; // String implements Debug

    fn add(&mut self, item: Self::Item) {
        self.elements.push(item);
    }

    fn print_all(&self) {
        for item in &self.elements {
            println!("Item: {:?}", item); // Uses Debug formatting
        }
    }
}

fn main() {
    let mut debug_vec = DebugVec { elements: vec![] };
    debug_vec.add(String::from("Hello"));
    debug_vec.add(String::from("World"));
    debug_vec.print_all();
}

الأنواع المرتبطة ذات القيم الافتراضية

trait Processor {
    type Input = String; // Default input type
    type Output = String; // Default output type

    fn process(&self, input: Self::Input) -> Self::Output;
}

struct SimpleProcessor;

impl Processor for SimpleProcessor {
    // Here, we use the default Input and Output types (String)
    fn process(&self, input: String) -> String {
        format!("Processed: {}", input.to_uppercase())
    }
}

struct CustomIntProcessor;

impl Processor for CustomIntProcessor {
    type Input = i32; // Override default Input
    type Output = i32; // Override default Output

    fn process(&self, input: i32) -> i32 {
        input * 2
    }
}

fn main() {
    let simple = SimpleProcessor;
    println!("Simple processor: {}", simple.process(String::from("hello rust")));

    let custom = CustomIntProcessor;
    println!("Custom int processor: {}", custom.process(10));
}

متى تختار الأنواع المرتبطة؟

تحقق من فهمك

مراجعة: الأنواع المرتبطة