Rust
iterators

परिचय

अनुकूल और उपभोक्ता

Iterator तरीकों को दो अलग-अलग समूहों में विभाजित किया जा सकता है:

एडेप्टर

एडेप्टर एक इट्रेटर लेते हैं और दूसरा इटरेटर वापस करते हैं

//         Iterator  Adapter
//             |       |
let my_map = (1..6).map(|x| x * x);
println!("{:?}", my_map);

Map { iter: 1..6 }

ध्यान दें कि मानों की गणना नहीं की गई थी, जो इंगित करता है कि पुनरावृत्तियों का उत्सुकता से मूल्यांकन नहीं किया जाता है - पुनरावृत्त "आलसी" हैं।

उपभोक्ताओं

उपभोक्ता एक पुनरावृत्ति लेते हैं और पुनरावृत्ति के अलावा कुछ और वापस करते हैं, प्रक्रिया में पुनरावृत्ति का उपभोग करते हैं।

//                    Iterator  Adapter       Consumer
//                        |       |              |
let my_squares: Vec<_> = (1..6).map(|x| x * x).collect();
println!("{:?}", my_squares);

[1, 4, 9, 16, 25]

उपभोक्ताओं के अन्य उदाहरणों में शामिल हैं find , fold , और sum ।

let my_squared_sum: u32 = (1..6).map(|x| x * x).sum();
println!("{:?}", my_squared_sum);

55

एक संक्षिप्त परिक्षण परीक्षण

fn is_prime(n: u64) -> bool {
    (2..n).all(|divisor| n % divisor != 0)
}

बेशक यह एक तेज़ परीक्षा नहीं है। हम n वर्गमूल पर परीक्षण रोक सकते हैं:

(2..n)
    .take_while(|divisor| divisor * divisor <= n)
    .all(|divisor| n % divisor != 0)

कस्टम पुनरावृत्त

struct Fibonacci(u64, u64);

impl Iterator for Fibonacci {
    type Item = u64;
    
    // The method that generates each item
    fn next(&mut self) -> Option<Self::Item> {
        let ret = self.0;
        self.0 = self.1;
        self.1 += ret;
        
        Some(ret) // since `None` is never returned, we have an infinite iterator
    }

    // Implementing the `next()` method suffices since every other iterator
    // method has a default implementation
}

उदाहरण का उपयोग करें:

// the iterator method `take()` is an adapter which limits the number of items
// generated by the original iterator
for i in Fibonacci(0, 1).take(10) {
    println!("{}", i);
}