Rust چیست و داور چطور کدت را اجرا می‌کند؟

خوش آمدی به Rust!

تبریک می‌گویم — تصمیم گرفته‌ای یکی از قدرتمندترین و محبوب‌ترین زبان‌های دنیای برنامه‌نویسی را یاد بگیری. پیش از آنکه اولین خطِ کدت را بنویسی، بیا چند دقیقه وقت بگذاریم و یک مدلِ ذهنیِ درست بسازیم: Rust چیست، چطور اجرا می‌شود، و در این پلتفرم دقیقاً چه اتفاقی برای کدِ تو می‌افتد. این چند پاراگراف، ستونِ فقراتِ کلِ دوره است؛ اگر آن‌ها را خوب بفهمی، بقیه‌ی مسیر هموار می‌شود.

۱) Rust چیست و چرا؟

Rust یک زبانِ کامپایل‌شونده، سریع و سیستمی است — یعنی برنامه‌هایش با همان سرعتِ زبان‌هایی مثلِ C و ++C اجرا می‌شوند و می‌توانند از سیستم‌عاملِ کوچک گرفته تا مرورگر و موتورِ بازی را بسازند. اما Rust یک ویژگیِ منحصربه‌فرد دارد که آن را از همه متمایز می‌کند: کامپایلر پیش از اجرا، جلوی بسیاری از باگ‌های حافظه و هم‌روندی را می‌گیرد — و این کار را بدونِ garbage collector (سطلِ زباله‌ی خودکار) انجام می‌دهد. یعنی هم سریع است، هم ایمن. نگران نباش؛ این جمله الان شاید مبهم باشد، اما در طولِ دوره دقیقاً می‌فهمی منظور چیست.

۲) مدلِ «اول کامپایل، بعد اجرا»

این مهم‌ترین تفاوتِ Rust با زبانی مثلِ پایتون است. در پایتون، مفسر کد را خط‌به‌خط تفسیر می‌کند و همان‌جا اجرا می‌کند. اما در Rust دو مرحله‌ی جدا داریم:

1. کامپایل: ابزاری به‌نامِ rustc (کامپایلرِ Rust) کلِ کدِ تو را می‌خواند و آن را به یک فایلِ اجراییِ ماشین تبدیل می‌کند — فایلی که پردازنده مستقیم می‌فهمد.
2. اجرا: سپس آن فایلِ اجرایی اجرا می‌شود و خروجی تولید می‌کند.
   نتیجه‌ی مهمِ این مدل: اگر کدِ تو حتی یک خطای نوعی یا نحوی داشته باشد، کامپایل شکست می‌خورد و برنامه اصلاً اجرا نمی‌شود. در پایتون ممکن بود نیمی از برنامه اجرا شود و بعد به خطا بخورد؛ در Rust یا همه‌چیز درست است و اجرا می‌شود، یا کامپایلر همان اول جلویت را می‌گیرد. این سخت‌گیری در ابتدا کمی اذیت‌کننده است، اما به‌زودی می‌بینی که چقدر از باگ‌ها را پیش از اجرا حذف می‌کند.

۳) داورِ ما دقیقاً همین کار را می‌کند

در این پلتفرم، تو در هر تمرین یک فایلِ کاملِ main.rs می‌نویسی. وقتی روی Run یا Check می‌زنی، داورِ ما پشتِ صحنه همان دو مرحله را انجام می‌دهد:

• ابتدا فایلت را با rustc نسخه‌ی 1.68.2 کامپایل می‌کند.
• اگر کامپایل موفق بود، فایلِ اجرایی را اجرا می‌کند و خروجی‌اش را می‌سنجد.
  دو محدودیتِ زمانی را همین حالا به خاطر بسپار:
• کامپایل: حداکثر ۱۵ ثانیه (کامپایلرِ Rust سنگین است، پس کمی وقت می‌دهیم).
• اجرا: حداکثر ۳ ثانیه.
  اگر برنامه‌ات کامپایل نشود یا در اجرا کندتر از حد باشد (مثلاً در یک حلقه‌ی بی‌پایان گیر کند)، تمرین را رد می‌شوی. پس کدِ تمیز و کارا بنویس.

۴) فقط std — بدونِ crate و بدونِ اینترنت

دنیای Rust یک مخزنِ بزرگِ بسته‌ها به‌نامِ crates.io و ابزاری به‌نامِ cargo دارد که با آن‌ها می‌توان کتابخانه‌های آماده (که به آن‌ها crate می‌گویند) را دانلود و استفاده کرد. اما داورِ ما به اینترنت دسترسی ندارد و فقط کتابخانه‌ی استانداردِ Rust — که به آن std می‌گویند — در دسترس است.
یعنی در کلِ این دوره خبری از این‌ها نیست: نه rand (برای اعداد تصادفی)، نه serde یا JSON، نه regex، نه tokio یا async. فقط std و خلاقیتِ خودت. این را یک محدودیت نبین، بلکه یک هدیه ببین: یاد می‌گیری همه‌چیز را با ابزارهای پایه — مثلِ .parse()، حلقه‌ها، تکرارگرها (iterators)، تطبیقِ الگو و مجموعه‌های استاندارد مثلِ Vec و HashMap — خودت بسازی. این دقیقاً همان مهارتی است که یک برنامه‌نویسِ واقعی را می‌سازد.

۵) اسکلتِ هر برنامه‌ی Rust

حالا بیا کوچک‌ترین برنامه‌ی کاملِ Rust را ببینیم. این چند خط، قالبِ ثابتی است که در هر تمرین تکرار می‌شود:

fn main() {
    println!("سلام");
}

بیا خط‌به‌خط بشکافیمش:

• fn کوتاه‌شده‌ی function (تابع) است — با آن یک تابع تعریف می‌کنیم.
• main نامِ یک تابعِ ویژه است: برنامه همیشه از اینجا شروع می‌شود. هر برنامه‌ی اجرایی دقیقاً یک fn main دارد.
• () پرانتزِ تابع است (فعلاً خالی).
• { ... } آکولادها، بدنه‌ی تابع‌اند؛ هر کاری که تابع انجام می‌دهد، داخلِ این آکولادها نوشته می‌شود.
• println! یک ماکرو برای چاپ است. به آن علامتِ تعجبِ ! در انتها دقت کن — همین ! نشانه‌ی ماکرو بودنش است. فعلاً اصلاً نگرانِ معنیِ دقیقِ «ماکرو» نباش؛ همین‌قدر بدان که println! یعنی «این متن را چاپ کن و به خطِ بعد برو».
• متنی که می‌خواهیم چاپ شود داخلِ گیومه‌ی دوتایی "..." می‌آید.
• و در پایان، هر دستور با یک نقطه‌ویرگول ; تمام می‌شود.
  این پنج‌شش نکته را خوب به خاطر بسپار؛ همین حالا در درسِ بعد اولین برنامه‌ات را با دقیقاً همین قالب می‌نویسی.

۶) کامپایلر، هم‌داورِ پنهانِ توست

این مهم‌ترین پیامِ این مقاله است: در Rust کامپایلر سخت‌گیر است، اما این سخت‌گیری به نفعِ توست. وقتی کدت اشتباهی داشته باشد، کامپایلر پیغامِ خطایی می‌دهد که اغلب بسیار دقیق و آموزنده است — معمولاً دقیقاً می‌گوید مشکل در کدام خط است، چرا اشتباه است، و حتی پیشنهادِ اصلاح می‌دهد.
پس به‌جای آنکه از خطاهای کامپایل بترسی، آن‌ها را معلمِ دومِ خود ببین. هر بار که کامپایلر خطایی می‌دهد، آن را با دقت بخوان؛ بسیاری از مفاهیمِ Rust را همین پیام‌ها به تو یاد می‌دهند. این یک ذهنیتِ کلیدی است که برنامه‌نویس‌های موفقِ Rust دارند.
یک نکته‌ی جانبی: ابزاری به‌نامِ rustfmt سبکِ رسمیِ قالب‌بندیِ کدِ Rust است — مثلاً تورفتگی (indent) را ۴ فاصله‌ای می‌کند. از همین حالا عادت کن کدِ تمیز و مرتب بنویسی؛ این عادت در ادامه‌ی مسیر خیلی به کارت می‌آید.

۷) دو مدلِ نمره‌دهی (یک نگاهِ کوتاه)

در این دوره تمرین‌ها به دو شکل سنجیده می‌شوند:

• بعضی تمرین‌ها یک خروجیِ ثابت می‌خواهند (به این مدل OUTPUT_MATCH می‌گوییم) — برنامه‌ات را اجرا می‌کنیم و خروجی‌اش را با یک متنِ مشخص مقایسه می‌کنیم.
• بعضی دیگر با ورودی‌های مختلف سنجیده می‌شوند (به این مدل TEST_CASES می‌گوییم) — برنامه‌ات چند بار با ورودی‌های گوناگون اجرا می‌شود.
  جزئیاتِ کاملِ این دو مدل و این‌که داور دقیقاً چه چیزهایی را می‌بخشد و چه چیزهایی را نمی‌بخشد، در مقاله‌ی پایانیِ همین ماژول می‌بینی. فعلاً همین‌قدر بدان که هر دو مدل، فقط به خروجیِ برنامه‌ی تو نگاه می‌کنند.

حالا وقتِ نوشتن است

خب، مدلِ ذهنی ساخته شد: کد می‌نویسی، کامپایلر آن را وارسی می‌کند، اجرا می‌شود، و خروجی سنجیده می‌شود. به‌جای ترس از کامپایلر، آن را هم‌تیمیِ خودت ببین. حالا دیگر وقتش رسیده که از حرف به عمل برسیم — بزن بریم اولین برنامه‌ی Rust‌مان را بنویسیم!