Comment puis-je effectuer une itération sur une plage avec une étape personnalisée?

Comment puis-je effectuer une itération sur une gamme de couleur Rouille avec une étape autre que 1? Je suis venue à partir d'un C++ arrière-plan, donc j'aimerais faire quelque chose comme

for(auto i = 0; i <= n; i+=2) {
    //...
}

À Rust-je besoin pour utiliser le range fonction, et il ne semble pas comme il y a un troisième argument disponibles pour avoir une étape personnalisée. Comment puis-je y arriver?

InformationsquelleAutor Syntactic Fructose | 2015-01-11
  1. 60

    range_step_inclusive et range_step ont disparu depuis longtemps.

    Comme de la Rouille 1.28, Iterator::step_by est stable:

    fn main() {
    for x in (1..10).step_by(2) {
        println!("{}", x);
    }
}
    InformationsquelleAutor Pill
  2. 9

    Il me semble que jusqu'à ce que le .step_by méthode est rendue stable, on peut facilement accomplir ce que vous voulez avec un Iterator (qui est ce que Ranges sont vraiment de toute façon):

    struct SimpleStepRange(isize, isize, isize);  //start, end, and step

impl Iterator for SimpleStepRange {
    type Item = isize;

    #[inline]
    fn next(&mut self) -> Option<isize> {
        if self.0 < self.1 {
            let v = self.0;
            self.0 = v + self.2;
            Some(v)
        } else {
            None
        }
    }
}

fn main() {
    for i in SimpleStepRange(0, 10, 2) {
        println!("{}", i);
    }
}

    Si on a besoin d'itérer plusieurs plages de différents types, le code peut être faite générique comme suit:

    use std::ops::Add;

struct StepRange<T>(T, T, T)
    where for<'a> &'a T: Add<&'a T, Output = T>,
          T: PartialOrd,
          T: Clone;

impl<T> Iterator for StepRange<T>
    where for<'a> &'a T: Add<&'a T, Output = T>,
          T: PartialOrd,
          T: Clone
{
    type Item = T;

    #[inline]
    fn next(&mut self) -> Option<T> {
        if self.0 < self.1 {
            let v = self.0.clone();
            self.0 = &v + &self.2;
            Some(v)
        } else {
            None
        }
    }
}

fn main() {
    for i in StepRange(0u64, 10u64, 2u64) {
        println!("{}", i);
    }
}

    Je vais le laisser pour vous d'éliminer la partie supérieure de vérification de limites pour créer un open ended structure si une boucle infinie est nécessaire...

    Avantages de cette approche est qu'travaille avec for la cabane à sucre et continuer à travailler même lorsque fonctionnalités instables deviennent utilisables; aussi, à la différence de la de-sucrées en utilisant l'approche standard Ranges, il ne perd pas en efficacité par de multiples .next() appels. Les inconvénients sont qu'il faut un peu de lignes de code pour configurer l'itérateur donc ne peut être vaut la peine pour le code qui a beaucoup de boucles.

    • Par l'ajout d'un autre type, U à votre deuxième option, vous pouvez utiliser les types de support d'addition avec un type différent et rendement encore un T. Par exemple, l'heure et la durée viennent à l'esprit.
    • cela semble être une bonne idée et devrait fonctionner, avec la structure définie comme suit: struct StepRange<T>(T, T, U), où pour la<'a, 'b> &'T: Ajouter<&" b U, Sortie = T>, T: PartialOrd, T: Clone; ce qui devrait permettre des durées différentes pour l'entrée T et U types.
    InformationsquelleAutor GordonBGood
  3. 3

    Vous voulez écrire votre code C++:

    for (auto i = 0; i <= n; i += 2) {
    //...
}

    ...dans la Rouille comme suit:

    let mut i = 0;
while i <= n {
    //...
    i += 2;
}

    Je pense que la Rouille version est plus lisible aussi.

    • Et si vous en quelque sorte insérer une "continuer" dans la boucle, vous êtes mort...
    • Re: insertion de "continuer" dans la boucle, on pourrait le faire uniquement à l'intérieur d'une branche conditionnelle, même dans la structure, je pense. Si oui, alors je pense qu'il serait OK pour incrémenter à l'intérieur de la branche conditionnelle dans la structure avant de "continuer"-ing, et qu'elle pourrait alors fonctionner comme prévu. Ou suis-je surplombant quelque chose?
    InformationsquelleAutor kmky
  4. 3

    Utiliser le num caisse avec range_step

    InformationsquelleAutor cambunctious
  5. 1

    Si vous entrez par quelque chose de prédéfini, et les petits comme les 2, vous souhaitez peut-être utiliser l'itérateur à l'étape manuellement. par exemple:

    let mut iter = 1..10;
loop {
    match iter.next() {
        Some(x) => {
            println!("{}", x);
        },
        None => break,
    }
    iter.next();
}

    Vous pouvez même utiliser cette étape par une quantité arbitraire (même si c'est certainement de plus en plus longues et plus difficiles à digérer):

    let mut iter = 1..10;
let step = 4;
loop {
    match iter.next() {
        Some(x) => {
            println!("{}", x);
        },
        None => break,
    }
    for _ in 0..step-1 {
        iter.next();
    }
}
    InformationsquelleAutor Leigh McCulloch