मैं कस्टम सीमा के साथ किसी श्रेणी पर कैसे पुनरावृति कर सकता हूं?

Question 1

मैं 1 से एक कदम के साथ जंग में एक सीमा पर पुनरावृति कैसे कर सकता हूं? मैं C ++ बैकग्राउंड से आ रहा हूं इसलिए मैं कुछ ऐसा करना चाहूंगा

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

जंग में मुझे rangeफ़ंक्शन का उपयोग करने की आवश्यकता होती है , और ऐसा नहीं लगता है कि एक कस्टम कदम रखने के लिए तीसरा तर्क उपलब्ध है। मैं यह कैसे हासिल कर सकता हूं?

Question 2

range_step_inclusiveऔर range_stepलंबे समय से चले गए हैं।

रूस्ट 1.28 के अनुसार, Iterator::step_byस्थिर है:

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

Question 3

यह मुझे लगता है कि जब तक .step_byविधि को स्थिर नहीं किया जाता है, तब तक कोई भी आसानी से पूरा कर सकता है जो आप चाहते हैं Iterator(जो कि Rangeवास्तव में वैसे भी हैं):

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

यदि किसी को विभिन्न प्रकारों की कई श्रेणियों को पुनरावृत्त करना है, तो कोड को निम्नानुसार सामान्य बनाया जा सकता है:

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

यदि अपरिमित लूप की आवश्यकता है, तो एक खुली हुई संरचना बनाने के लिए ऊपरी सीमा की जांच को समाप्त करने के लिए मैं इसे आपको छोड़ दूँगा ...

इस दृष्टिकोण का लाभ यह है कि चीनी के साथ काम करता है forऔर अस्थिर सुविधाओं के उपयोग योग्य होने पर भी काम करना जारी रखेगा; इसके अलावा, मानक Ranges का उपयोग करते हुए डी-शर्करा वाले दृष्टिकोण के विपरीत , यह कई .next()कॉलों द्वारा दक्षता नहीं खोता है । नुकसान यह है कि इटेरेटर सेट करने के लिए कोड की कुछ पंक्तियां लगती हैं इसलिए केवल कोड के लिए इसके लायक हो सकता है जिसमें बहुत सारे लूप हों।

Question 4

Num_step के साथ num crate का उपयोग करें

Question 5

आप अपना C ++ कोड लिखेंगे:

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

... जैसे जंग में:

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

मुझे लगता है कि जंग संस्करण अधिक पठनीय है।

Question 6

यदि आप पूर्वनिर्धारित किसी चीज से कदम बढ़ा रहे हैं, और 2 की तरह छोटा है, तो आप मैन्युअल रूप से कदम रखने के लिए पुनरावृत्त का उपयोग करना चाह सकते हैं। उदाहरण के लिए:

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

आप इसे एक मनमानी राशि के अनुसार भी उपयोग कर सकते हैं (हालांकि यह निश्चित रूप से पचने में लंबा और कठिन है):

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