Generics Generics

النبذة

هنا يحدث التحوّل الأكبر في تفكيرك: الأنواع تتوقّف عن كونها ثوابت، وتصير قيماً تُمرَّر إلى دوال. Generic هو دالةٌ على مستوى الأنواع: تأخذ نوعاً، تُعيد نوعاً. هذه ليست ميزة جانبية؛ إنها اللحظة التي يتحوّل فيها نظام الأنواع من "جدول تحقّق" إلى لغة برمجة بذاتها. وإن كنت قلقاً من "generics"، فالخبر السار: أنت تعرفها أصلاً من C — هذه void* لكن مع حفظ النوع، وهي قوالب C++ لكن مدمجة في اللغة. سنشتقّها من المشكلة التي تحلّها، لا كصياغةٍ تُحفظ.

اللغز المستفزّ

تريد دالة identity تُعيد ما تستقبله. حاول بما تملك من الإقليم ٢:

typescript
function identity(x: unknown): unknown {
  return x;
}
const a = identity(5);     // نوع a؟
a.toFixed(2);              // ؟

a نوعه unknown — فقدتَ المعلومة أن المُدخَل كان رقماً! unknown ابتلع النوع. لو استعملت any بدلها، لمرّ a.toFixed() لكنك أطفأت المُبرهِن (الإقليم ٢). المعضلة:

unknown و any كلاهما يفشل: الأول ينسى، الثاني يتعامى. تحتاج شيئاً ثالثاً — متغيّراً يحمل النوع. فكّر: في C، حين أردت دالةً تعمل على أي نوع، استعملت void* وضحّيت بالنوع. ماذا لو استطعت الاحتفاظ به؟

الدرس

Generic = معاملٌ من نوع "نوع"

الحل أن نُدخل متغيّر نوع (type parameter): اسمٌ يقف مكان نوعٍ لا نعرفه بعد، يُملأ عند الاستدعاء.

typescript
function identity<T>(x: T): T {
  return x;
}
const a = identity(5);      // T استُنتج = number؛  a نوعه number
a.toFixed(2);               // ✅
const b = identity("hi");   // T = string؛  b نوعه string

<T> تُعلن "هذه الدالة مُعاملة بنوعٍ اسمه T". في كل استدعاء، يُستنتَج T من الوسيط (هنا 5 ⟹ T = number)، ويُستبدل في كل مكان. ربطنا المُخرَج بالمُدخَل عبر اسمٍ مشترك T دون أن نعرف قيمته مسبقاً. هذا حرفياً دالةٌ تأخذ نوعاً وتُعيد نوعاً — لكنها تُنفَّذ وقت الترجمة، في عالم الأنواع، ثم تُمحى مع كل شيء آخر (جدار الإقليم ٠ ما زال قائماً: <T> تختفي في الناتج).

ربطٌ بخبرتك: في C++ هذه template<typename T> تماماً. في C، أقرب ما لديك void* — لكنها تنسى النوع وتجبرك على cast يدوي خطر. Generic تعطيك مرونة void* بلا فقدان النوع وبلا cast: المترجم يتتبّع T لك. في Python، أقرب شيء TypeVar في type hints — نفس الفكرة، نفس الدافع.

القيود (constraints): generic لا يعني "أي شيء بلا شروط"

identity<T> تقبل أي T لأنها لا تلمس بنية x. لكن ماذا لو احتجت أن تفعل شيئاً بـ x؟

typescript
function longest<T>(a: T, b: T): T {
  return a.length > b.length ? a : b;   // ❌ T قد لا يكون له length
}

المترجم محقّ: T قد يكون number (بلا .length). أنت لا تريد أي نوع، بل أي نوع له طولٌ. تقول هذا بـ extends:

typescript
function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length > b.length ? a : b;
}
longest("abc", "de");        // ✅ T = string (للنصوص length)
longest([1,2], [3]);          // ✅ T = number[]
longest(1, 2);                // ❌ number ليس له length — مرفوض عند الاستدعاء

T extends C تعني — بلغة المجموعات التي تعرفها — "T يجب أن يكون نوعاً فرعياً من C"، أي مجموعة T ⊆ مجموعة C. إنها تحدّ نطاق T المسموح. لاحظ الجمال: extends هنا ليست وراثة (كما في Java)، بل شرط احتواء مجموعات — نفس ⊆ من الإقليم ١، يطفو الآن لمستوى الأنواع. هذه الكلمة extends ستعود في الإقليم ٨ بمعنى "اختبار ⊆"، وهو المعنى نفسه بالضبط.

لماذا generic أقوى من overloading أو الاتحاد

قد تسأل: لماذا لا أكتب longest(a: string | number[], ...)؟ لأن ذلك يفقد الربط: الاتحاد يسمح بخلط longest("a", [1]) ويُرجع string | number[] ضبابياً. أمّا <T extends ...> فيفرض أن المُدخَلين نفس النوع ويُعيد ذلك النوع بعينه. Generic لا يعطيك مرونةً فقط، بل يحفظ العلاقات بين المدخلات والمخرجات — وهذا جوهر قيمته. إنه يبرمج بالأنواع، لا يكتفي بقبولها.

Generics على الأنواع نفسها (لا الدوال فقط)

أيّ نوعٍ يمكن أن يكون قالباً، لا الدوال وحدها:

typescript
type Box<T> = { value: T };
type Pair<A, B> = { first: A; second: B };
type Maybe<T> = T | null;

const b: Box<number> = { value: 5 };
const p: Pair<string, number> = { first: "id", second: 1 };

Box دالةٌ على مستوى الأنواع: أعطها number تُعِد { value: number }. هكذا بُنيت كل البنى المعروفة: Array<T> (نعم، T[] مجرّد اختصار لـ Array<T>)، Promise<T> (وعدٌ بقيمة T لاحقاً)، Map<K, V>, Record<K, V>. كلها قوالب تأخذ أنواعاً. حين ترى Promise<User>، اقرأها: "طبّقت دالة النوع Promise على User".

الاستنتاج (inference): المترجم يملأ T عنك

لاحظ أنك نادراً ما تكتب identity<number>(5) صراحةً؛ تكتب identity(5) والمترجم يستنتج T = number من الوسيط. هذا الاستنتاج محرّك ذكي يحلّ "ما النوع الذي لو وُضع مكان T لاتّسقت كل القيود؟". أحياناً يفشل أو يوسّع أكثر مما تريد، فتتدخّل صراحةً بـ <...>. اربطه بـ auto و template argument deduction في C++: نفس الدور — اشتقاق النوع من السياق.

القيمة الافتراضية وتعدّد المعاملات

typescript
type Container<T = string> = { items: T[] };   // افتراضي إن لم يُمرَّر
type Dict<V> = Record<string, V>;

كلّها امتدادٌ مباشر للفكرة: معاملات نوعٍ متعدّدة، بعضها بقيمٍ افتراضية، تماماً كمعاملات الدوال العادية. النظام منسجمٌ مع نفسه — ولهذا يستحقّ أن يُتعلَّم بالاشتقاق لا بالحفظ: متى أمسكت "Generic = دالة على الأنواع"، استنتجت البقية.

اللغز / التمرين

الخلاصة — وصلٌ في الشجرة