Konstruktion von benutzerdefinierten Lazy-Array-Filter-Kombinatoren

struct LazyFilter<'a, T, F> {
    slice: &'a [T],
    predicate: F,
    index: usize,
}
 
impl<'a, T, F> LazyFilter<'a, T, F>
where
    F: Fn(&T) -> bool,
{
    fn new(slice: &'a [T], predicate: F) -> Self {
        Self { slice, predicate, index: 0 }
    }
}
 
impl<'a, T, F> Iterator for LazyFilter<'a, T, F>
where
    F: Fn(&T) -> bool,
{
    type Item = &'a T;
 
    fn next(&mut self) -> Option<Self::Item> {
        while self.index < self.slice.len() {
            let element = &self.slice[self.index];
            self.index += 1;
            if (self.predicate)(element) {
                return Some(element);
            }
        }
        None
    }
}
 
fn process_data() -> Vec<i32> {
    let numbers = [1, 2, 3, 4, 5, 6];
    let filter = LazyFilter::new(&numbers, |&x| x % 2 == 0);
    filter.copied().collect()
}