Как итерироваться по диапазону чисел с нестандартным шагом в Rust?

Использование метода step_by() из трейта Iterator

Проблема, с которой вы столкнулись, заключается в том, что step_by() — это метод трейта Iterator, который доступен для любого итератора, включая Range. Однако в Rust трейты должны быть явно импортированы в область видимости. В стандартной библиотеке Iterator уже находится в прелюдии (prelude), поэтому метод step_by() доступен без дополнительных импортов. Ваш код почти правильный, но есть небольшая синтаксическая ошибка: step_by принимает usize, а не просто число с плавающей запятой или любой целочисленный тип.

Вот исправленный пример:

fn main() {
    // Правильный способ: шаг 3, итерация от 0 до 99 включительно
    for i in (0..100).step_by(3) {
        println!("{}", i);
    }
}

Этот код выведет: 0, 3, 6, 9, ..., 99. Обратите внимание, что 0..100 — это полуоткрытый диапазон (не включает 100), поэтому последним значением будет 99 (кратное 3). Если вам нужно включить 100, используйте 0..=100 (включительно).

Альтернативные подходы

Если вам нужно больше контроля или вы работаете с нецелыми числами, рассмотрите следующие варианты:

• Использование filter(): Если шаг нерегулярный или вы хотите отфильтровать значения по условию, можно комбинировать filter с проверкой остатка от деления:

fn main() {
    for i in (0..100).filter(|x| x % 3 == 0) {
        println!("{}", i);
    }
}

• Использование while цикла: Для полного контроля над шагом можно использовать классический цикл while:

fn main() {
    let mut i = 0;
    while i < 100 {
        println!("{}", i);
        i += 3;
    }
}

• Использование for с range_step из крейта itertools: Если вы часто работаете со сложными итерациями, крейт itertools предоставляет множество полезных функций, включая range_step:

// Добавьте в Cargo.toml: itertools = "0.12"
use itertools::Itertools;

fn main() {
    for i in (0..100).step(3) {
        println!("{}", i);
    }
}

Почему работает step_by()?

Метод step_by() определён в стандартной библиотеке для трейта Iterator. Он создаёт новый итератор, который пропускает n-1 элементов после каждого возвращённого элемента. Это ленивая операция — она не выделяет память и не вычисляет все значения заранее. Важно помнить, что step_by принимает аргумент типа usize, поэтому если у вас есть переменная другого целочисленного типа, её нужно привести:

let step: i32 = 3;
for i in (0..100).step_by(step as usize) {
    println!("{}", i);
}

Также стоит отметить, что step_by работает с любыми итераторами, не только с диапазонами. Например, вы можете применить его к вектору:

let numbers = vec![1, 2, 3, 4, 5, 6];
for n in numbers.iter().step_by(2) {
    println!("{}", n); // Выведет: 1, 3, 5
}

Таким образом, решение вашей проблемы — просто использовать step_by(3) на диапазоне. Это идиоматичный и эффективный способ в Rust.

struct StepRange {
    start: i32,
    end: i32,
    step: i32,
}

impl Iterator for StepRange {
    type Item = i32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.start >= self.end {
            None
        } else {
            let current = self.start;
            self.start += self.step;
            Some(current)
        }
    }
}

fn main() {
    let range = StepRange { start: 0, end: 100, step: 3 };
    for i in range {
        println!("{}", i);
    }
}