كيفية استخدام أنواع البيانات المعممة Generic Data Types في لغة Rust

تُعد أنواع البيانات المعممة (Generics) من أبرز الخصائص في لغة Rust، إذ تُوفر وسيلة قوية لإعادة استخدام الكود بمرونة وكفاءة دون التضحية بأداء التنفيذ أو أمان النوع (Type Safety). وتُمكّن المبرمجين من كتابة دوال، تراكيب بيانات (Structs)، تعدادات (Enums)، وسمات (Traits) يمكنها العمل مع أنواع متعددة بدلاً من الاقتصار على نوع محدد. في هذا السياق، يُعد فهم كيفية استخدام الأنواع المعممة ضروريًا لبناء مكتبات قوية، وتصميم واجهات مرنة، وتحقيق أهداف البرمجة العامة بطريقة فعالة.

المفهوم الأساسي للـ Generics

في لغات البرمجة التي تدعم Generics، يمكن للدوال أو الكائنات أن تعمل على أنواع متعددة دون الحاجة إلى تكرار الكود. هذا المفهوم موجود في C++ تحت اسم templates، وفي Java وC# باسم generics، وفي Rust يُستخدم بتصميم صارم يُراعي أداء الكود وأمان النوع من خلال نظام النوع الثابت في وقت الترجمة.

في Rust، تُستخدم الأنواع المعممة عن طريق المعاملات النوعية (Type Parameters) والتي تُكتب بين أقواس زاويّة <>. على سبيل المثال:

rust
CopyEdit
fn identidade(x: T) -> T {
    x
}

الدالة identidade تُعيد القيمة التي تستقبلها بغض النظر عن نوعها، بشرط أن يكون النوع متطابقًا في المعطى والعائد. العامل T هو نوع معمم يُحدده المستخدم عند استدعاء الدالة.

أنواع الاستخدام: الدوال والمعاملات النوعية

الدوال هي أحد أكثر المواضع التي يظهر فيها استخدام Generics. المثال أعلاه بسيط، لكنه يوضح كيفية تعريف واستخدام معامل نوع عام. عند استدعاء الدالة، يستطيع المترجم تحديد النوع تلقائيًا:

rust
CopyEdit
let x = identidade(42);        // النوع: i32
let y = identidade("نص");      // النوع: &str

الميزة الرئيسية هنا أن المترجم لا يتعامل مع هذه الدوال كما لو كانت ديناميكية، بل يُولّد نسخة مخصصة منها لكل نوع تُستخدم معه، مما يُبقي الأداء عاليًا دون كلفة التنفيذ الديناميكي.

استخدام Generics في Structs

يمكن استخدام الأنواع المعممة في تعريف Structs لتكون مرنة وتقبل أنواعًا متعددة:

rust
CopyEdit
struct Ponto {
    x: T,
    y: T,
}

هذا الهيكل Ponto يمكنه تمثيل نقطة ثنائية الأبعاد لأي نوع رقمي أو غير رقمي. مثال على استخدامه:

rust
CopyEdit
let ponto1 = Ponto { x: 5, y: 10 };          // النوع: i32
let ponto2 = Ponto { x: 1.0, y: 4.5 };       // النوع: f64

من الممكن أيضًا تعريف Struct يستخدم أكثر من نوع:

rust
CopyEdit
struct PontoGenerico {
    x: T,
    y: U,
}

وهذا يسمح بتكوين هيكل يحتوي على عناصر من أنواع مختلفة في نفس الوقت.

Generics في Enums

التعدادات أيضًا تستفيد من الأنواع العامة. المثال الكلاسيكي هو Option:

rust
CopyEdit
enum Option {
    Some(T),
    None,
}

هذا التعداد يُستخدم للتعبير عن إمكانية وجود قيمة أو لا. عند استخدامه، يتم تحديد النوع ضمن أقواس الزاوية:

rust
CopyEdit
let talvez_numero: Option<i32> = Some(5);
let nada: Option<i32> = None;

مثال آخر هو Result الذي يُمثل نتيجة قد تكون ناجحة (T) أو خاطئة (E):

rust
CopyEdit
enum Result {
    Ok(T),
    Err(E),
}

Generics في Implementations

يمكن أيضًا استخدام الأنواع المعممة عند تنفيذ التراكيب (Structs) أو التعدادات (Enums). مثال على ذلك:

rust
CopyEdit
impl Ponto {
    fn coordenada_x(&self) -> &T {
        &self.x
    }
}

في هذا المثال، يتم تنفيذ دالة coordenada_x لأي نوع T يُستخدم في Ponto. يمكن أيضًا كتابة تنفيذات مخصصة لأنواع محددة:

rust
CopyEdit
impl Ponto<f64> {
    fn distancia_da_origem(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

هذا التنفيذ ينطبق فقط على Ponto، ويُضيف وظيفة حساب المسافة من نقطة الأصل.

استخدام قيود الأنواع (Trait Bounds)

عند استخدام الأنواع العامة، قد ترغب أحيانًا بتقييدها لتكون متوافقة مع سلوك معين، أي أن تدعم Trait معيّن. يُستخدم هذا لتحديد الخصائص التي يجب أن تتوفر في الأنواع المستخدمة.

rust
CopyEdit
fn maiorPartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

في هذا المثال، يُشترط أن يكون النوع T داعمًا للمقارنة الجزئية (PartialOrd) حتى نتمكن من استخدام عامل >.

يمكن أيضًا استخدام Trait Bounds في تراكيب Structs أو Implementations:

rust
CopyEdit
struct ContainerClone> {
    valor: T,
}

ويمكن دمج عدة Traits:

rust
CopyEdit
fn imprimir_valorClone>(x: T) {
    println!("{}", x);
}

استخدام Where لتنسيق أفضل

في حال كانت القيود على النوع كثيرة، يمكن استخدام الكلمة المفتاحية where لتحسين قراءة الكود:

rust
CopyEdit
fn combinar(a: T, b: U) -> String
where
    T: std::fmt::Display,
    U: std::fmt::Display,
{
    format!("{}{}", a, b)
}

يُوفر هذا الأسلوب تنسيقًا أكثر وضوحًا، خصوصًا في الدوال الطويلة أو المعقدة.

الأنواع المعممة المرتبطة (Associated Types)

في بعض الحالات، قد لا يكون من العملي تمرير الأنواع كمعاملات، وهنا تُستخدم الأنواع المرتبطة داخل Traits. مثال من مكتبة Rust القياسية هو:

rust
CopyEdit
trait Iterador {
    type Item;
    fn proximo(&mut self) -> Option<Self::Item>;
}

عند تنفيذ هذا Trait، يتم تحديد نوع العنصر:

rust
CopyEdit
struct Contador;

impl Iterador for Contador {
    type Item = u32;

    fn proximo(&mut self) -> Option<u32> {
        Some(1)
    }
}

الأنواع المرتبطة تُوفر مرونة أكبر عندما تكون العلاقة بين نوع المعطى ونوع العائد أكثر تعقيدًا.

Lifetimes مع Generics

في Rust، النظام الآمن للذاكرة يعتمد على الـ Lifetimes التي تُحدد فترة حياة المرجع. في بعض الحالات، يجب تحديد الـ Lifetimes في سياق استخدام Generics:

rust
CopyEdit
fn retornar_maior<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a > b { a } else { b }
}

في هذا المثال، نُخبر المترجم أن القيمة المُعادة لها نفس فترة الحياة للمرجعين المدخلين. من دون هذا التحديد، سيحدث خطأ ترجمة متعلق بإمكانية وجود مرجع غير صالح.

الجدول التالي يلخّص أشكال استخدام Generics في لغة Rust:

أهمية Generics في تصميم البرمجيات

تُعد أنواع البيانات المعممة ضرورة في تصميم المكتبات التي تُستخدم على نطاق واسع. يُمكن للمكتبات أن توفر وظائف عامة وقوية تدعم أنواعًا مختلفة دون الحاجة لتكرار الكود أو التضحية بالأداء. من خلال استخدام Generics، يمكن للبرمجيات أن تكون أكثر مرونة وقابلة لإعادة الاستخدام في سيناريوهات متعددة.

كما تُسهم في فصل واجهة الكود عن تنفيذه، مما يُعزز مبدأ فصل الاهتمامات (Separation of Concerns)، ويسهل تطوير البرامج واختبارها وصيانتها.

الخاتمة

تُشكل Generics جزءًا أساسيًا من هندسة البرمجيات الحديثة، ولغة Rust تُقدم واحدة من أقوى وأشد تطبيقات Generics صرامة وأمانًا في وقت الترجمة. من خلال دمج الأنواع العامة مع ميزات مثل Trait Bounds وLifetimes والأنواع المرتبطة، يمكن للمبرمجين تصميم كود مرن، فعال وآمن. هذه الخصائص تجعل Rust خيارًا ممتازًا للتطبيقات التي تتطلب أمان الذاكرة والأداء العالي مع المحافظة على بنية برمجية نظيفة وقابلة لإعادة الاستخدام.

المصادر

1. The Rust Programming Language – https://doc.rust-lang.org/book/ch10-01-syntax.html

2. Rust by Example – https://doc.rust-lang.org/rust-by-example/generics.html