روز ۳۹: Iterator‌ها و Functional Style در Rust به‌صورت عمیق و عملی

یکی از نقاط تمایز مهم Rust نسبت به بسیاری از زبان‌های سیستمی دیگر، پشتیبانی قدرتمند آن از سبک برنامه‌نویسی Functional است. Iterator‌ها در Rust نه‌تنها ابزاری برای پیمایش داده‌ها هستند، بلکه هسته‌ی اصلی نوشتن کدهای تمیز، ایمن و بهینه محسوب می‌شوند. در Rust، Iterator‌ها به شکلی طراحی شده‌اند که هم خوانایی کد را افزایش دهند و هم بدون هزینه‌ی اضافی در زمان اجرا عمل کنند. درک عمیق Iterator‌ها باعث می‌شود از حلقه‌های تودرتو و کدهای تکراری فاصله بگیرید و به سمت کدی اعلامی، قابل نگهداری و حرفه‌ای حرکت کنید.

مفهوم Iterator در Rust چیست؟

Iterator در Rust یک Trait است که به شما اجازه می‌دهد روی مجموعه‌ای از داده‌ها به‌صورت ترتیبی حرکت کنید. هر Iterator متدی به نام next دارد که در هر فراخوانی، مقدار بعدی را برمی‌گرداند. این مقدار از نوع Option است و وقتی داده‌ها تمام شوند، مقدار None برگردانده می‌شود. همین طراحی ساده، پایه‌ی بسیاری از قابلیت‌های پیشرفته Rust را تشکیل می‌دهد و به کامپایلر اجازه می‌دهد کدهای بسیار بهینه تولید کند.

let numbers = vec![1, 2, 3, 4];
let mut iter = numbers.iter();

println!("{:?}", iter.next());
println!("{:?}", iter.next());

در این مثال، iter یک Iterator روی Vec است که به عناصر آن به صورت reference دسترسی دارد. این رفتار باعث می‌شود مالکیت داده حفظ شود و از کپی‌های غیرضروری جلوگیری شود.

تفاوت iter، iter_mut و into_iter

یکی از بخش‌های مهم کار با Iterator‌ها در Rust، درک تفاوت بین iter، iter_mut و into_iter است. این سه روش رفتار متفاوتی در زمینه‌ی Ownership دارند و انتخاب درست آن‌ها تأثیر زیادی روی طراحی کد دارد. iter عناصر را به صورت reference می‌دهد، iter_mut اجازه‌ی تغییر عناصر را می‌دهد و into_iter مالکیت داده‌ها را منتقل می‌کند.

let v = vec![10, 20, 30];

for x in v.iter() {
    println!("{}", x);
}

در این حالت، v بعد از حلقه همچنان قابل استفاده است. اما اگر از into_iter استفاده شود، مالکیت عناصر منتقل شده و دیگر نمی‌توان از v استفاده کرد. این تفاوت دقیقاً همان جایی است که Rust شما را مجبور می‌کند آگاهانه درباره‌ی حافظه تصمیم بگیرید.

Iterator‌ها و Lazy Evaluation

Iterator‌ها در Rust به‌صورت Lazy عمل می‌کنند، یعنی تا زمانی که واقعاً به داده نیاز نباشد، هیچ محاسبه‌ای انجام نمی‌شود. این ویژگی باعث می‌شود زنجیره‌ای از عملیات بدون هزینه‌ی اضافی ساخته شود و فقط در زمان مصرف نهایی اجرا شود. Lazy بودن Iterator‌ها یکی از دلایل اصلی کارایی بالای کدهای Functional در Rust است.

let result = vec![1, 2, 3, 4]
    .iter()
    .map(|x| x * 2)
    .filter(|x| *x > 4)
    .collect::<Vec<_>>();

در این مثال، map و filter تا زمانی که collect فراخوانی نشود، اجرا نمی‌شوند. این موضوع به Rust اجازه می‌دهد کل زنجیره را بهینه‌سازی کند و از ساختارهای میانی غیرضروری جلوگیری شود.

Functional Style و متدهای پرکاربرد Iterator

Rust مجموعه‌ای بسیار غنی از متدهای Iterator ارائه می‌دهد که امکان نوشتن کدهای Functional و خوانا را فراهم می‌کنند. متدهایی مانند map، filter، fold، any، all و find از پرکاربردترین ابزارها هستند. این متدها باعث می‌شوند منطق برنامه به‌صورت واضح و بدون جزئیات پیاده‌سازی بیان شود.

let sum = vec![1, 2, 3, 4]
    .iter()
    .fold(0, |acc, x| acc + x);

println!("{}", sum);

در این مثال، fold بدون نیاز به متغیر mutable یا حلقه‌ی صریح، مجموع اعداد را محاسبه می‌کند. این سبک کدنویسی هم امن‌تر است و هم احتمال بروز خطا را کاهش می‌دهد.

مقایسه Functional Style با Loopهای سنتی

یکی از سوالات رایج این است که آیا Iterator‌ها نسبت به حلقه‌های for سنتی کندتر هستند یا خیر. پاسخ کوتاه این است که در Rust، Iterator‌ها معمولاً به همان اندازه سریع یا حتی سریع‌تر هستند. کامپایلر Rust با استفاده از Zero-Cost Abstraction، Iterator‌ها را به کدی معادل حلقه‌های دستی تبدیل می‌کند. این یعنی شما خوانایی و ایمنی را بدون پرداخت هزینه‌ی کارایی به دست می‌آورید.

for x in &vec![1, 2, 3] {
    println!("{}", x);
}

و نسخه‌ی Functional آن:

vec![1, 2, 3].iter().for_each(|x| println!("{}", x));

هر دو نسخه در نهایت به کدی بسیار مشابه در سطح ماشین تبدیل می‌شوند.

ترکیب Iterator‌ها با String و HashMap

Iterator‌ها فقط برای Vec نیستند و تقریباً روی تمام Collectionهای استاندارد Rust کار می‌کنند. شما می‌توانید روی String، HashMap و حتی Structهای سفارشی Iterator پیاده‌سازی کنید. این انعطاف‌پذیری باعث می‌شود Functional Style در کل پروژه گسترش پیدا کند.

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert("a", 1);
map.insert("b", 2);

let values_sum: i32 = map.values().sum();

در این مثال، متد values یک Iterator برمی‌گرداند که می‌توان به‌راحتی با آن عملیات Functional انجام داد.

پیاده‌سازی Iterator سفارشی

یکی از ویژگی‌های قدرتمند Rust این است که می‌توانید Iterator مخصوص خودتان را پیاده‌سازی کنید. این کار با پیاده‌سازی Trait Iterator انجام می‌شود و امکان ساخت APIهای بسیار تمیز و حرفه‌ای را فراهم می‌کند.

struct Counter {
    count: u32,
}

impl Iterator for Counter {
    type Item = u32;

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

این مثال نشان می‌دهد که Iterator‌ها فقط یک ابزار آماده نیستند، بلکه یک الگوی طراحی قدرتمند در Rust محسوب می‌شوند.

جمع‌بندی نهایی

Iterator‌ها و Functional Style بخش جدایی‌ناپذیر Rust مدرن هستند و یادگیری آن‌ها تأثیر مستقیمی روی کیفیت کد شما دارد. این مفاهیم باعث می‌شوند کدها کوتاه‌تر، خواناتر و ایمن‌تر باشند، بدون اینکه کارایی قربانی شود. با تسلط بر Iterator‌ها، شما نه‌تنها در Rust حرفه‌ای‌تر می‌شوید، بلکه دید بهتری نسبت به طراحی سیستم‌های بزرگ و تمیز پیدا می‌کنید. این مبحث پلی است بین مفاهیم پایه و موضوعات پیشرفته‌تری مثل Async، Stream و Concurrency در Rust.