面试题：Rust Iterator trait的自定义适配器方法

Question

在Rust中，假设已有一个实现了Iterator trait的结构体MyIterator，要求你为其实现一个自定义的适配器方法`filter_and_transform`，该方法接收一个闭包，先对迭代器中的元素进行过滤，只保留满足闭包条件的元素，然后对这些元素进行转换，返回一个新的迭代器。请给出具体的代码实现。

Answer 1

struct MyIterator {
    data: Vec<i32>,
    index: usize,
}

impl Iterator for MyIterator {
    type Item = i32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.index < self.data.len() {
            let item = self.data[self.index];
            self.index += 1;
            Some(item)
        } else {
            None
        }
    }
}

trait MyIteratorAdapter {
    fn filter_and_transform<F, G, U>(self, f: F, g: G) -> FilterAndTransform<Self, F, G>
    where
        Self: Sized,
        F: FnMut(&Self::Item) -> bool,
        G: FnMut(Self::Item) -> U;
}

impl<I> MyIteratorAdapter for I
where
    I: Iterator,
{
    fn filter_and_transform<F, G, U>(self, f: F, g: G) -> FilterAndTransform<Self, F, G>
    where
        Self: Sized,
        F: FnMut(&Self::Item) -> bool,
        G: FnMut(Self::Item) -> U,
    {
        FilterAndTransform {
            iter: self,
            filter_fn: f,
            transform_fn: g,
        }
    }
}

struct FilterAndTransform<I, F, G> {
    iter: I,
    filter_fn: F,
    transform_fn: G,
}

impl<I, F, G, U> Iterator for FilterAndTransform<I, F, G>
where
    I: Iterator,
    F: FnMut(&I::Item) -> bool,
    G: FnMut(I::Item) -> U,
{
    type Item = U;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            let item = self.iter.next()?;
            if (self.filter_fn)(&item) {
                return Some((self.transform_fn)(item));
            }
        }
    }
}

你可以这样使用：

fn main() {
    let my_iter = MyIterator {
        data: vec![1, 2, 3, 4, 5],
        index: 0,
    };

    let result: Vec<i32> = my_iter.filter_and_transform(|&x| x % 2 == 0, |x| x * 2).collect();
    println!("{:?}", result);
}