في fullstack تعلّمتَ: الإغلاق (closure) = كود + بيئة مُلتقَطة على الـ heap، وهي الآلية التي تفسّر callbacks وhooks في JS. الجزء الذي لم تحتَجه هناك: JS تلتقط البيئة بطريقة واحدة دائمًا — مرجع مشترك لصندوق قابل للتغيير على الـ heap، يديره الـ GC. Rust ترفض إجابة واحدة موحّدة — لأنها ترفض أي افتراض لم تثبته البديهيتان. هذا الإقليم يريك كيف تتحلل "الالتقاط" إلى نفس الثلاثية التي تعيش معك منذ الإقليم ٠١، وكيف أن for نفسها — التي تكتبها منذ سطرك الأول — كانت طوال الوقت واجهة لآلة لم ترها بعد.

الدرس ١: الإغلاقات — ثلاثة أزياء لثلاثية واحدة

اللغز

الحل: Fn / FnMut / FnOnce

let s = String::from("hi");
let read_it = || println!("{s}");        // يلتقط s بـ &  → Fn
read_it(); read_it();                     // يُستدعى مرات بلا مشكلة

let mut count = 0;
let mut bump = || { count += 1; };        // يلتقط count بـ &mut → FnMut
bump(); bump();                           // مُستدعى مرات، لكن يحتاج وصولًا حصريًا لنفسه

let name = String::from("bye");
let consume = move || { let _owned = name; };  // move يجبر الالتقاط بالتمليك → FnOnce
consume();
// consume();   // error: هذا closure من نوع FnOnce — والقيمة الملتقَطة نُقلت بالفعل

المترجم يستنتج أضيق التقاط ممكن تلقائيًا من جسم الإغلاق (تمامًا كما يستنتج نوع let x = 5) — لا تكتب Fn/FnMut/FnOnce بيدك أبدًا عند التعريف، فقط عند اشتراطها كقيد على معامل دالة. الكلمة move تجبر الالتقاط بالتمليك حتى لو كانت الاستعارة كافية — ستحتاجها كل مرة تريد فيها لإغلاق أن يعيش أطول من النطاق الحالي (تلميح: هذا بالضبط ما يحتاج إليه خيط جديد في الإقليم ٠٨).

الثلاثة تُشكّل تراتبية، لا مجموعات منفصلة — تذكّر من TS: subtype = subset. هنا: كل Fn هي أيضًا FnMut (من يستطيع الاكتفاء بقراءة، يستطيع منطقيًا العمل ضمن عقد أضعف يطلب فقط استدعاءً متكررًا)، وكل FnMut هي أيضًا FnOnce (من يستطيع أن يُستدعى مرات، يستطيع أن يُستدعى مرة واحدة على الأقل). الأقوى ضمانًا (Fn) هو الأضيق نطاق تطبيق فعليًا؛ الأضعف ضمانًا (FnOnce) هو الأعم.

الإغلاق كنوع، لا كصندوق موحّد

في JS كل دالة/closure قيمة من "نوع" واحد غامض. في Rust كل إغلاق نوعه الخاص المجهول، حجمه على الـ stack يساوي بالضبط حجم ما التقطه (صفر إن لم يلتقط شيئًا — عندها هو حرفيًا مؤشر دالة عادي). هذا امتداد مباشر لزيرو-كوست الإقليم ٠٤: لا صندوق heap إجباري، لا GC يتتبعه — إلا إن طلبتَ ذلك صراحة:

fn make_adder(x: i32) -> impl Fn(i32) -> i32 { move |y| x + y }   // static — نوع محدد وقت الترجمة
fn pick(op: char) -> Box<dyn Fn(i32, i32) -> i32> {                // dynamic — قائمة/تخزين غير متجانس
    match op {
        '+' => Box::new(|a, b| a + b),
        _   => Box::new(|a, b| a - b),
    }
}

نفس ثنائية impl Trait مقابل dyn Trait من الإقليم ٠٤ بالحرف — لأن الإغلاق، تحت غطاء الصياغة الخاصة |x| ...، هو نوع يطبّق trait (أحد الثلاثة)، لا شيء أكثر سحرًا من ذلك.

الدرس ٢: المنتِج (Iterator) — الآلة التي كانت تعمل تحت for طوال الوقت

اللغز

الحل: Iterator

trait Iterator {
    type Item;                                  // نوع مرتبط — رأيته يلمح في ٠٤
    fn next(&mut self) -> Option<Self::Item>;   // Option! نفس التي بنيت حدسها في ٠٣
}

هذا التعريف الكامل تقريبًا (المكتبة القياسية تضيف عشرات الطرق الافتراضية فوقه، مبنية جميعًا على next وحدها). for ليست جملة تحكّم خاصة — إنها سكّر نحوي كامل فوق هذه الآلية:

for x in 0..5 { println!("{x}"); }

// يوازي تمامًا:
let mut it = (0..5).into_iter();
while let Some(x) = it.next() {
    println!("{x}");
}

"متى تتوقف" لم يعد حسابًا يدويًا — أصبح None. المستحيل نحويًا صار: قراءة خارج الحدود، لأن لا فهرسة يدوية أصلًا في هذا النمط. هذا الجواب الكامل على لغز الإقليم ٠٠.

ابنِ واحدًا بيدك أولًا

قبل الاتكال على مكتبة الأدوات الجاهزة، ابنِ منتِجًا من الصفر — هكذا فقط تفهم أن map/filter ليست سحرًا بل دوال عادية فوق next:

struct Countdown(u32);
impl Iterator for Countdown {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.0 == 0 { None } else { self.0 -= 1; Some(self.0 + 1) }
    }
}
for n in (Countdown(3)) { println!("{n}"); }   // 3 2 1

الكسل (laziness) وصفر التخصيص

let total: i32 = (1..=1_000_000).filter(|n| n % 3 == 0).map(|n| n * 2).sum();

لا شيء "يحدث" عند كتابة .filter(...).map(...) — هذه تركّب سلسلة منتِجين متداخلين، كل واحد يغلّف الذي قبله، بلا تخصيص أي Vec وسيط. الحساب الفعلي يبدأ فقط عند نداء مُستهلِك (consumer) مثل .sum() أو .collect() أو for، ويسحب عنصرًا عنصرًا عبر السلسلة كاملة قبل طلب التالي. المترجم — بفضل monomorphization (الإقليم ٠٤) — يحوّل هذه السلسلة إلى حلقة واحدة مضغوطة بلا أي طبقة تنسيق إضافية، مطابقة تمامًا لما كنت لتكتبه يدويًا بحلقة C واحدة يدوية. زيرو-كوست، مرة أخرى، مطبَّقة هنا بالحرف.

جولة سريعة على الأشهر (لا شرح لكل واحدة — واضحة من اسمها وتوقيعها؛ جرّبها): map, filter, enumerate (يُرفق فهرسًا usize — بديل آمن لحساب i اليدوي)، zip, take(n), skip(n), rev, fold(init, f) (تعميم sum/ sum نفسها)، collect::<Vec<_>>() (لاحظ ::<> — turbofish، تحسم للمترجم أي نوع تريد التجميع فيه حين لا يكفي السياق للاستنتاج).

الثلاثية تظهر مجددًا — هذه المرة في for

for x in &v      { /* x: &T     — استعارة قراءة، يستدعي .iter()     */ }
for x in &mut v  { /* x: &mut T — استعارة حصرية، يستدعي .iter_mut() */ }
for x in v       { /* x: T      — تمليك كامل، يستدعي .into_iter()، v تموت بعدها */ }

توقف هنا. هذه نفس الثلاثية بالحرف التي رأيتها في استقبال الطرق (&self/&mut self/self، الإقليم ٠٤) وفي التقاط الإغلاقات (Fn/ FnMut/FnOnce، قبل قليل). ليست ثلاث ميزات منفصلة تحفظها — إنها مظهر واحد متكرر لبديهيتَي الإقليمين ٠١-٠٢، يعاد توظيفه في كل موضع تحتاج فيه اللغة أن تسأل "كيف تصل لهذه القيمة؟". حين تلتقي بنمط ثلاثي جديد لاحقًا في اللغة، اسأل أولًا: أهذه الثلاثية نفسها متنكرة مرة أخرى؟ غالبًا الجواب نعم.

الدرس ٣: حل مطبّ العربي — UTF-8 من جذوره

في ٠٢-ج طُلب منك أن تراقب مطبًّا مع النصوص العربية بلا إصلاح. حان وقت التفسير الكامل.

• String تخزّن بايتات UTF-8 صحيحة دائمًا — invariant يحرسه النوع نفسه (لا طريقة لإدخال بايتات غير صالحة إلا عبر unsafe، الإقليم ٠٩).
• char (تذكّر ٠٠: ٤ بايتات في الذاكرة كقيمة) يمثّل Unicode scalar value واحدة — لكن ترميزها في الـ buffer الفعلي متغيّر الطول: حرف ASCII = بايت واحد، حرف عربي (أغلب مدى ٠٦٠٠–٠٦FF) = بايتان عادةً، بعض الرموز والإيموجي = ٣-٤ بايتات.
• s.len() تُرجع عدد البايتات، لا عدد الأحرف. جملة عربية بعشرة أحرف ظاهرة قد يكون طولها ٢٠ بايتًا. من افترض "بايت لكل حرف" (حساب فهرسة يدوي، أو s.len() كعدّاد أحرف) — ينكسر فورًا مع العربية، ولا ينكسر أبدًا مع الإنجليزية المحضة. هذا بالضبط ما كنت لتصطدم به لو بنيتَ ٠٢-ج بحساب مواضع يدوي بدل الاعتماد الكامل على char_indices().
• الفهرسة المباشرة s[i] بعدد صحيح غير موجودة أصلًا لـ String — فقط &s[a..b] بمدى بايتات، ويُفزِّع (panic) فورًا إن لم يقع a أو b تمامًا على حد حرف (char boundary). فهرسة C بايت-بايت التي اعتدتها ممنوعة قصدًا هنا — كانت لتنتج نصًّا مشوّهًا بصمت، أو نصف رمز عربي مقطوعًا في المنتصف.
• .chars() (منتِج قيم char، يحترم الحدود دائمًا) و.char_indices() (منتِج أزواج (usize, char) حيث الـ usize مضمون أن يقع على حد حرف صحيح) هما الطريقة الآمنة الوحيدة للمشي حرفًا-حرفًا. .bytes() متاحة أيضًا حين تريد البايتات الخام صراحة.

تحقّق الآن: عد لحل ٠٢-ج، وإن كنتَ استعملتَ char_indices() بحذافيرها (لا حسابًا يدويًا فوقها) فستجده يعمل مع العربية بلا تعديل — لأن الحدود كانت محروسة طوال الوقت. إن لم يعمل، الآن تعرف بالضبط أين الافتراض الخاطئ كان يختبئ. (ملاحظة أخيرة تستحق أن تُعلَّق لا أن تُشرح الآن: حتى char ليست نهاية القصة — بعض ما يبدو "حرفًا واحدًا" للعين البشرية (رموز مركّبة، تشكيل) قد يتكوّن من عدة char معًا؛ يتجاوز عمق هذا المنهج.)

معلم البناء: أداة بحث نصية من الصفر

ابنِ أداة سطر أوامر — سمّها ما شئت — تُشبه grep مصغّرة. هذا معلم لا لغز مُغلَق: صمّم تفاصيلك، لكن التزم بهذه المتطلبات لأنها تُجبرك على تركيب كل ما تعلمته من الإقليم ٠٠ حتى الآن في نظام واحد متماسك:

الوظيفة:

• تقرأ نمط بحث (pattern) واسم ملف من std::env::args().
• تطبع كل سطر يحوي النمط، مسبوقًا برقم السطر.
• تدعم علمًا --ignore-case (تجاهل حالة الأحرف) وعلمًا --count (اطبع العدد فقط، لا الأسطر).

القيود المعمارية (إلزامية):

• منطق البحث يجب أن يُبنى بسلسلة منتِجين (lines() → enumerate() → filter(...) → ...) — ممنوع أي حلقة for بجسم فيه حساب فهرسة يدوي للبحث عن التطابق نفسه (تعداد الأسطر أو المطابقة عبر enumerate/ filter/map فقط). يسمح for فقط لطباعة النتيجة النهائية إن احتجتَه.
• افصل بين "المنطق" و"الواجهة": دالة (أو أكثر) تُرجع Result<Vec<(usize, &str)>, ...> أو ما شابه (استعمل ما بنيتَه في ٠٥-ب كإلهام — أعمار المُخرَج مربوطة بعمر محتوى الملف لا بعمر أي شيء آخر)، ودالة main منفصلة تتعامل فقط مع القراءة والطباعة والخروج.
• الأخطاء (نمط مفقود، ملف غير موجود، ملف غير قابل للقراءة) تُعالَج بـ Result و? — ممنوع أي unwrap()/expect()/panic!() خارج main نفسها. اجعل توقيع main نفسه -> Result<(), Box<dyn std::error::Error>> (نوع خطأ موحَّد يبتلع أي نوع خطأ عبر dyn Error — إعادة توظيف مباشرة لـ dyn من الإقليم ٠٤، لأن io::Error وأي خطأ آخر تصنعه أنواع مختلفة يحتاج توحيدها تحت سقف واحد). اطبع رسائل الخطأ عبر eprintln! (أخت println! لكن لمخرج الأخطاء stderr)، واخرج بشيفرة غير صفرية عبر std::process::exit(1) عند الفشل.
• جرّب أداتك على ملف يحوي أسطرًا عربية وإنجليزية مختلطة، وتحقّق أن الأرقام والتطابق سليمان مع الاثنين.

لا حلّ مرجعيًا لهذا المعلم في المنهج. اختبر أداتك يدويًا على ملفات حقيقية حتى تثق بها.

الألغاز

let v = vec![1, 2, 3];
let a = || println!("{v:?}");

let mut total = 0;
let b = |n: i32| { total += n; };

let s = String::from("owned");
let c = move || s.len();

let mut buf = String::new();
let d = move |x: &str| { buf.push_str(x); buf.clone() };

الخلاصة

• العقدة الجديدة: الإغلاقات (Fn/FnMut/FnOnce) والمنتِجات (Iterator, next, الكسل، صفر التخصيص) — كلاهما تركيبان فوق ما بنيتَه سلفًا، لا أساسان جديدان.
• الوصلة للخلف (الأهم في هذا الإقليم): ثلاثية {تمليك، استعارة قراءة، استعارة حصرية} من الإقليمين ٠١-٠٢ ليست قاعدة عابرة — إنها النمط التوليدي للغة كلها. رأيتها الآن في: استقبال الطرق (٠٤)، التقاط الإغلاقات، وأنماط for الثلاثة. وOption من ٠٣ ليست مجرد بديل لـ null — إنها الآلية الحرفية التي تعرف بها كل حلقة for متى تتوقف. ومطبّ العربي من ٠٢ وُلد وحُلّ في نفس الإقليم.
• الوصلة للأمام: أداة البحث التي بنيتَها تعمل على ملف واحد، بترتيب متسلسل. ماذا لو أردتَ البحث في عشرة ملفات معًا، في وقت واحد فعليًا، مستفيدًا من أكثر من نواة معالج؟