Kolleksiyalar, qapanmalar və iteratorlar

Müəllim hər dərsdən sonra jurnala yeni qiymətlər əlavə edir — siyahı böyüyür. Sonra o, hansı qiymətin neçə dəfə yazıldığını saymaq istəyir — bu isə «açar → say» lüğətidir. Real proqramların əksəriyyəti məhz belə kolleksiyalarla işləyir. Rust-da bunun üçün Vec və HashMap, onları emal etmək üçün isə güclü iteratorlar var.

Vec — böyüyən siyahı

Vec<T> eyni tipli elementlərin heap-də saxlanılan, ölçüsü dəyişə bilən siyahısıdır. Onu vec![...] makrosu və ya Vec::new() ilə yaradırlar. push sona element əlavə edir, pop sonuncunu çıxarıb Option qaytarır, len isə uzunluğu verir. v[i] sərhəddən kənarda panikaya düşür, v.get(i) isə None qaytarı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 — açar və qiymət

HashMap<K, V> hər açara bir qiymət uyğunlaşdırır və onu std::collections-dan qoşmaq lazımdır. insert cüt əlavə edir, get isə Option<&V> qaytarır. Sayğac qurmağın ən qısa yolu entry API-dir: entry(açar).or_insert(0) açar yoxdursa, onu 0 ilə yaradır və qiymətə dəyişən istinad qaytarı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)]

Qapanmalar (closures)

Qapanma (closure) yerindəcə yazılan adsız funksiyadır: |parametrlər| gövdə. Onun parametr tiplərini adətən yazmaq lazım olmur — kompilyator istifadədən çıxarır. Qapanmanın əsas xüsusiyyəti ətrafdakı dəyişənləri tutmasıdır: aşağıda add_bonus bonus-u oxuyur, click isə clicks-i dəyişir, ona görə özü də mut elan olunub.

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

İteratorlar: map, filter, collect

v.iter() elementləri bir-bir verən iterator yaradır. map (hər elementi çevir) və filter (şərtə uyğunları saxla) kimi adapterlər tənbəldir: özləri heç nə hesablamır, yalnız plan qurur. İş collect, sum, count, max kimi yekun metod çağırılanda başlayır. collect-ə nəticənin tipini göstərmək lazımdır, məsələn, 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();