Iterators

Links:

Итераторы

Итераторы позволяют выполнять действия по очереди над цепочкой данных. Итератор берёт каждый объект цепочки и проверяет, не последний или он. Итераторы в Rust - ленивые, т.е не отрабатывают, пока не будет вызван метод, который их поглощает.

iter()

Возвращает Iterator<Item = &T>, забирает на себя массив без изменений (immutable), поэтому исходный массив далее доступен для других действий. Применять для задач чтения.

let v1 = [1, 2, 3]; 
let v1_iter = v1.iter();

for val in v1_iter {  // iterator consume by for cycle
  println!("Got: {val}");
}
println!("{v1:?}"); // v1 доступен после итератора

into_iter()

Возвращает Iterator<Item = T>, делает move массиву, после применения массив использовать нельзя. Применять для задач изменений с исходным массивом.

    let v1 = [1, 2, 3];
    for num in v1.into_iter() {
        println!("{}", num); } // num is i32 (owned value)
    // println!("{v1:?}"); // ❌ ошибка, v1 перемещён

Когда ты пишешь for x in коллекция, Rust автоматически вызывает into_iter(), потому что это “по умолчанию” забирает коллекцию. Если хочешь оставить коллекцию, явно используй for x in коллекция.iter().

iter_mut()

Возвращает Iterator<Item = &mut T>, забирает на себя массив с возможностью его менять прямо на месте. Исходный массив далее доступен для других действий.

    let mut vec = vec![1, 2, 3];
    // Создает iterator по mutable rссылкам (&mut T)
    for num in vec.iter_mut() {
        *num *= 2; } // можно менять элементы 
    println!("Modified: {:?}", vec); // [2, 4, 6]

Цикл for с iter(), into_iter(), iter_mut()

Синтаксический сахар:

let vec = vec![1, 2, 3];

for x in vec.iter() { /* x: &i32 */ }
for x in &vec { /* x: &i32 */ }  // равно iter()

for x in vec.into_iter() { /* x: i32 */ }
for x in vec { /* x: i32 */ }  // равно into_iter()

for x in vec.iter_mut() { /* x: &mut i32 */ }
for x in &mut vec { /* x: &mut i32 */ }  // равно iter_mut()
Характеристикаiterinto_iteriter_mut
Что возвращаетСсылки (<T>)Сами значения (T)Изменяемые ссылки
(<mut T>)
Можно ли менять элементыНет, только смотретьДа, но коллекция уже твояДа, через ссылки
Что с коллекциейОстаётся живой“Исчезает” (перемещается)Остаётся живой
Тип итератораИтератор по ссылкамИтератор по значениямИтератор по изменяемым ссылкам
Когда использоватьХочу посмотреть элементыХочу забрать элементыХочу изменить элементы на месте
Требуется ли mut для коллекцииНетНет (но коллекция уходит)Да, коллекция должна быть mut
Пример кодаfor x in vec.iter()for x in vec.into_iter()for x in vec.iter_mut()
Пример результатаx — ссылка,
vec жив		x — значение,
vec мёртв		x — изменяемая ссылка,
vec жив

repeat, repeat_n, take, skip

repeat - создаёт строку, повторяя заданный символ N раз (N as usize). Например, вывести квадрат из символов “+” размера n (через клонирование):

fn generate_square(n: i32) -> String {
    vec!["+".repeat(n as usize); n as usize].join("\n") }

repeat_n - создаёт итератор, который возвращает заданный элемент N раз (N as usize) без клонирования (в отличие от repeat):

fn generate_square2(n: i32) -> String {
    std::iter::repeat_n(
        std::iter::repeat_n("+", n as usize).collect::<String>(),
        n as usize,
    )
    .collect::<Vec<_>>()
    .join("\n") }

take - возвращает первые N элементов итератора (N as usize), если итератор не исчерпает себя раньше:

fn generate_square3(n: i32) -> String {
    std::iter::repeat(std::iter::repeat("+").take(n as usize).collect::<String>()).take(n as usize).collect::<Vec<_>>().join("\n") }

take часто используют с бесконечным итератором для задания ему конечного числа итераций:

let mut iter = (0..).take(3);
assert_eq!(iter.next(), Some(0));
assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), None);

skip(n) создаёт новый итератор, в котором пропускает заданное число n элементов исходного итератора, а остальные возвращает. С помощью него удобно обрабатывать данные, пропустив заголовок, либо параметры введённой команды с пропуском имени самой команды:

use std::env;

fn main() {
    // env::args() = итератор на Strings с аргументами.
    // Вызываем skip(1) для пропуска пути к команде.
    let arguments = env::args().skip(1);

    // Клонируем clone() для проверки количества аргументом
    // сохраняя исходный итератор
    if arguments.clone().count() == 0 { 
        println!("No arguments provided other than the program name.");
    } else {
        println!("Processing arguments:");
        for arg in arguments {
            println!("  Argument: {}", arg);
        }}}

Вместе take() и skip() комбинируются, чтобы получить средние значения в массиве:

let data = [10, 20, 30, 40, 50, 60, 70, 80];
let iter = data.iter();
let middle_elements: Vec<_> = iter
    .skip(2) // пропуск 2 элементов
    .take(3) // взять 3 элемента = 30,40,50
    .collect(); // поместить результат в Vec.
println!("Middle elements: {:?}", middle_elements);

Отличие .map() и .flat_map()

Обе функции раскрывают итератор вектора, однако, с разным результатом:

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

    // Using `map()`
    let mapped: Vec<Vec<i32>> = numbers.iter().map(|&n| vec![n, n * 10]).collect();
    println!("{:?}", mapped); // [[1, 10], [2, 20], [3, 30]]

    // Using `flat_map()`
    let flat_mapped: Vec<i32> = numbers.iter().flat_map(|&n| vec![n, n * 10]).collect();
    println!("{:?}", flat_mapped); // [1, 10, 2, 20, 3, 30]
}

.map() - сохраняет структуру в итоговом результате .flat_map() - убирает лишние структуры

counts()

Считает число объектов в итераторе и возвращает как HashMap.

let text = "hello world".to_string();
println!("{:?}", text.chars().counts()); 
// {'d': 1, 'o': 2, ' ': 1, 'w': 1, 'e': 1, 'h': 1, 'r': 1, 'l': 3}

Заглядывающий (peekable) итератор

peekable() превращает обычный итератор в итератор, который позволяет посмотреть на следующий элемент, не продвигая итератор вперед.

let mut numbers = vec![1, 2, 3].into_iter().peekable();
// peek() - смотрим на следующий элемент, но не двигаем итератор
println!("Смотрим: {:?}", numbers.peek()); // Some(1)
println!("Смотрим ещё раз: {:?}", numbers.peek()); // Все ещё Some(1)
println!("Берём: {:?}", numbers.next()); // Some(1)
println!("Теперь смотрим: {:?}", numbers.peek()); // Some(2)
println!("Берём: {:?}", numbers.next()); // Some(2)
println!("Берём: {:?}", numbers.next()); // Some(3)
println!("Теперь смотрим: {:?}", numbers.peek()); // None

next_if() - взять элемент только если условие выполняется

let mut nums = vec![1, 3, 5, 2, 4].into_iter().peekable();
    // Берём все нечетные числа подряд
    while let Some(num) = nums.next_if(|x| *x % 2 == 1) {
        println!("{}", num);
    } // 1, 3, 5

Пример

Взятие символов в строке так, чтобы разбивать строку на пары из двух символов. Если строка содержит нечетное количество символов, то недостающий второй символ последней пары должен быть заменен на символ подчеркивания (’_’).

fn solution(s: &str) -> Vec<String> {
    let mut result = Vec::new();
    let mut chars = s.chars().peekable();  // Делаем итератор peekable
    while let Some(c1) = chars.next() {      // Берём первый символ пары
        let c2 = chars.next().unwrap_or('_'); // Второй или '_' если нет
        result.push(format!("{}{}", c1, c2)); // Собираем пару
    }   
    result
}