Qual è un modo stabile per iterare su un intervallo con passaggio personalizzato?

Question

Come devo andare se voglio ripetere con un passaggio personalizzato in Rust stabile? In sostanza qualcosa come il C/C++

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

} 

Ho già provato con range_step_inclusive e le soluzioni in 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); 
} 

ma sembra come se non è disponibile in Rust 1.1:

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

Quale sarebbe un'alternativa? Forse il modo idiomatico per creare intervalli personalizzati.

Answer 1

Come di Rust 1.1

Si può sempre scrivere fuori la vecchia maniera:

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

che possono poi essere astrarre:

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); 
    }) 
} 

Interessante nota a margine storica , Credo che in origine tutto il ciclo fosse fatto con chiusure come questa, prima che gli iteratori diventassero estremamente diffusi.

Answer 2

Non c'è modo usando let "ridefinizione":

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

Oppure utilizzare Iterator::map:

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

Answer 3

Penso che continuerò ad un ciclo while. Ma se si vuole veramente un metodo basato iteratore si potrebbe provare questo

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

Utilizzare il crate num

Cargo.toml:

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

Dal momento che è necessario solo nozioni di base della cassa, utilizzare default-features = false.

Rust:

extern crate num; 

use num::range_step; 

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

range_step è generico su tipi interi di ruggine.

Answer 5

È possibile utilizzare la funzione iterator_step_by.

Ecco un esempio di due thread in esecuzione, uno di loro stampare i numeri dispari e gli altri anche:

#![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(); 
} 

Senza questa funzionalità, è possibile utilizzare anche un filtro sulla gamma:

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(); 
}