Koleksiyonlar, closure'lar ve yineleyiciler

Öğretmen her dersten sonra deftere yeni notlar ekler; liste büyür. Sonra hangi notun kaç kez yazıldığını saymak ister; bu da bir “anahtar → sayı” sözlüğüdür. Gerçek programların çoğu tam olarak bu tür koleksiyonlarla çalışır. Rust'ta bunun için Vec ve HashMap, onları işlemek için de güçlü yineleyiciler (iterator) vardır.

Vec — büyüyen liste

Vec<T>, öbekte saklanan, aynı türde elemanlardan oluşan, boyutu değişebilen bir listedir. vec![...] makrosuyla ya da Vec::new() ile oluşturulur. push sona eleman ekler, pop sonuncuyu çıkarıp bir Option döndürür, len ise uzunluğu verir. v[i] sınır dışında panikler, v.get(i) ise None döndürür.

fn main() {
    let mut scores = vec![72, 95, 88];
    scores.push(64);
    println!("{:?} len={}", scores, scores.len());
    println!("first = {}", scores[0]);
    println!("get(10) = {:?}", scores.get(10));

    if let Some(last) = scores.pop() {
        println!("popped {last}");
    }
    for s in &mut scores {
        *s += 5;
    }
    println!("{:?}", scores);
}

[72, 95, 88, 64] len=4
first = 72
get(10) = None
popped 64
[77, 100, 93]

HashMap — anahtarlar ve değerler

HashMap<K, V>, her anahtara bir değer eşler ve std::collections içinden içe aktarılması gerekir. insert bir çift ekler, get ise Option<&V> döndürür. Sayaç kurmanın en kısa yolu entry API'dir: entry(anahtar).or_insert(0), anahtar yoksa onu 0 ile oluşturur ve değerine değiştirilebilir bir referans döndürür.

use std::collections::HashMap;

fn main() {
    let text = "the cat and the dog and the bird";
    let mut counts: HashMap<&str, u32> = HashMap::new();
    for word in text.split_whitespace() {
        *counts.entry(word).or_insert(0) += 1;
    }
    println!("the: {:?}", counts.get("the"));
    println!("fish: {:?}", counts.get("fish"));

    let mut pairs: Vec<(&str, u32)> = counts.into_iter().collect();
    pairs.sort();
    println!("{:?}", pairs);
}

the: Some(3)
fish: None
[("and", 2), ("bird", 1), ("cat", 1), ("dog", 1), ("the", 3)]

Closure'lar

Closure, yerinde yazılan adsız bir fonksiyondur: |parametreler| gövde. Parametre türlerini genellikle yazmak gerekmez; derleyici onları kullanımdan çıkarır. Closure'ın temel özelliği çevresindeki değişkenleri yakalamasıdır: aşağıda add_bonus, bonus'u okur; click ise clicks'i değiştirir, bu yüzden kendisi de mut olarak bildirilmiştir.

fn main() {
    let bonus = 10;
    let add_bonus = |score: i32| score + bonus;
    let double = |x| x * 2;
    println!("{}", add_bonus(80));
    println!("{}", double(21));

    let mut clicks = 0;
    let mut click = || clicks += 1;
    click();
    click();
    println!("clicks = {clicks}");
}

90
42
clicks = 2

Yineleyiciler: map, filter, collect

v.iter(), elemanları tek tek veren bir yineleyici oluşturur. map (her elemanı dönüştür) ve filter (koşula uyanları tut) gibi bağdaştırıcılar tembeldir: kendileri hiçbir şey hesaplamaz, yalnızca bir plan kurar. İş, collect, sum, count ya da max gibi sonlandırıcı bir metot çağrıldığında başlar. collect'e sonucun türünü belirtmek gerekir, örneğin Vec<i32>.

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];

    let squares: Vec<i32> = numbers.iter().map(|n| n * n).collect();
    let evens: Vec<i32> = numbers.iter().copied().filter(|n| n % 2 == 0).collect();
    let total: i32 = numbers.iter().sum();
    let max = numbers.iter().max();

    println!("{:?}", squares);
    println!("{:?}", evens);
    println!("total = {total}, max = {max:?}");
    println!("{:?}", numbers);
}

[1, 4, 9, 16, 25, 36]
[2, 4, 6]
total = 21, max = Some(6)
[1, 2, 3, 4, 5, 6]

let names = vec!["aysel", "ali", "leyla", "rauf"];
let mut result = Vec::new();
for name in &names {
    if name.len() > 3 {
        result.push(name.to_uppercase());
    }
}

let names = vec!["aysel", "ali", "leyla", "rauf"];
let result: Vec<String> = names
    .iter()
    .filter(|name| name.len() > 3)
    .map(|name| name.to_uppercase())
    .collect();