Jaki jest stabilny sposób na iterowanie w zakresie z niestandardowym krokiem?

Question

Co powinienem zrobić, jeśli chcę przeprowadzić iterację z niestandardowym krokiem w stabilnej wersji Rust? Zasadniczo coś jak C/C++

for (int i = 0; i < n; i += 2) { 

} 

Ja już próbowałem przy użyciu range_step_inclusive i rozwiązania w How do I iterate over a range with a custom step?:

use std::iter::range_step_inclusive; 
for i in range_step_inclusive(0, n, 2) { 
    println!("i: {}", i); 
} 

Ale wydaje się, że nie jest ona dostępna w Rust 1.1:

error: unresolved import `std::iter::range_step_inclusive`. There is no `range_step_inclusive` in `std::iter` 

Jaka byłaby alternatywa? Prawdopodobnie idiomatyczny sposób tworzenia niestandardowych zakresów.

Answer 1

Jak Rust 1,1

Zawsze można napisać go w staromodny sposób:

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

które następnie mogą być pobieranej:

use std::ops::Add; 

fn step_by<T, F>(start: T, end_exclusive: T, step: T, mut body: F) 
    where T: Add<Output = T> + PartialOrd + Copy, 
      F: FnMut(T) 
{ 
    let mut i = start; 
    while i < end_exclusive { 
     body(i); 
     i = i + step;  
    } 
} 

fn main() { 
    step_by(0, 100, 2, |i| { 
     println!("i: {}", i); 
    }) 
} 

ciekawe historyczne marginesie Sądzę, że pierwotnie wszystkie pętle zostały wykonane z takimi zamknięciami, zanim iteratory stały się niezwykle rozpowszechnione.

Answer 2

Istnieje sposób korzystania let "przedefiniowanie":

for i in 0..((n + 1)/2) { 
    let i = i * 2; 
    // … 
} 

Albo użyć Iterator::map:

for i in (0..((n + 1)/2)).map(|i| i * 2) { 
    // … 
} 

Answer 3

myślę będę trzymać do pętli while. Ale jeśli naprawdę chcesz się metodę opartą iterator można spróbować tego

fn main(){ 
    let (start, step, end) = (1, 2, 20); 
    for i in (0..).map(|x| start+step*x) 
        .take_while(|&x| x<end){ 
     println!("{:?}", i); 
    } 
} 

Answer 4

Użyj crate num

Cargo.toml:

[dependencies.num] 
version = "0.1.25" 
default-features = false 

ponieważ trzeba tylko podstawy skrzyni, użyj default-features = false.

Rust:

extern crate num; 

use num::range_step; 

for i in range_step(0, 10, 2) { 
    /* */ 
} 

range_step jest nazwą rodzajową nad typów całkowitych Rust.

Answer 5

Można użyć funkcji iterator_step_by.

Oto przykład dwóch wątków uruchomiony jeden z nich drukując numery nieparzyste i inne nawet te:

#![feature(iterator_step_by)] 
extern crate thebook; 

use std::thread; 
use std::time::Duration; 
fn main() { 
    let handle = thread::spawn(|| { 
     for i in (1..1000).step_by(2) { 
      println!("{}", i); 
     } 
    }); 
    for i in (2..1000).step_by(2) { 
     println!("{}", i); 
    } 
    handle.join(); 
} 

bez tej funkcji, można również użyć filtra w zakresie:

use std::thread; 
use std::time::Duration; 
fn main() { 
    let handle = thread::spawn(|| { 
     for i in (1..1000).filter(|x| x % 2 != 0) { 
      println!("{}", i); 
     } 
    }); 
    for i in (2..1000).filter(|x| x % 2 == 0) { 
     println!("{}", i); 
    } 
    handle.join(); 
}