如何延长Rust中迭代器适配器内临时变量的生存期？

Question

我有一个方法make_iter()，它在Rust中创建一个具有多个适配器的Iterator，它可以简化为以下MCVE：

fn make_iter(first: &First) -> Box<dyn Iterator<Item = String> + '_> {
    Box::new(first.make_objects().flat_map(|second| {
        second
            .iter()
            .filter(|third| third.as_str() != "t2")
            .flat_map(|third| vec![format!("{}.A", third), format!("{}.B", third)].into_iter())
            .chain(
                vec![
                    format!("{}.A", second.name()),
                    format!("{}.B", second.name()),
                ]
                .into_iter(),
            )
    }))
}

pub fn main() {
    let first = First {};
    for i in make_iter(&first) {
        println!("{}", i);
    }
}

struct First {}

impl First {
    fn make_objects(&self) -> Box<dyn Iterator<Item = Second> + '_> {
        Box::new(
            vec![
                Second::new("s1".to_string()),
                Second::new("s2".to_string()),
                Second::new("s3".to_string()),
            ]
            .into_iter(),
        )
    }
}

struct Second {
    name: String,
    objects: Vec<String>,
}

impl Second {
    fn new(name: String) -> Second {
        Second {
            name,
            objects: vec!["t1".to_string(), "t2".to_string(), "t3".to_string()],
        }
    }

    fn name(&self) -> &str {
        &self.name
    }

    fn iter(&self) -> Box<dyn Iterator<Item = &String> + '_> {
        Box::new(self.objects.iter())
    }
}

试图编译此示例将产生一个生存期错误：

error[E0597]: `second` does not live long enough
  --> src/main.rs:3:9
   |
3  |         second
   |         ^^^^^^ borrowed value does not live long enough
...
14 |     }))
   |     - `second` dropped here while still borrowed

这是可以理解的，因为second对象是临时的，从同一闭包返回的迭代器试图借用它，因为second被丢弃在闭包的末尾时失败了。我的目标是延长这个对象的生存期，直到删除引用它的Iterator为止，但是我不知道怎么做。

请注意，结构实现不能更改。锈蚀版本为1.34.2,2018年版

Answer 1

延长此对象的生存期。

你不能这么做，就这样。事情不是这样运作的。

另请参阅：

• 延长变量寿命
• 延长字符串片的借入寿命
• 是否有任何方法返回对函数中创建的变量的引用？

这里有一个简单的复制：

use std::iter;

fn example(outer: impl Iterator<Item = Inner>) {
    outer.flat_map(|i| i.iter().map(|v| v.clone()));
}

struct Inner;

impl Inner {
    fn iter(&self) -> impl Iterator<Item = &()> + '_ {
        iter::empty()
    }
}

由于您有无法更改Inner的限制，最简单的解决方案是更加急切和主动地更改collect。

fn example(outer: impl Iterator<Item = Inner>) {
    outer.flat_map(|i| i.iter().map(|v| v.clone()).collect::<Vec<_>>());
}

我所知道的避免这种情况的唯一可能性是使用像租房或参考这样的机箱。

另请参阅：

• 是否有String::chars的自有版本？
• 如何将字符迭代器存储在与它正在迭代的字符串相同的结构中？

如果您有可能更改Inner，则应该使用迭代器变体。然后，由于迭代器获得了所有权，因此该值不需要存在于闭包之外。

use std::iter;

fn example(outer: impl Iterator<Item = Inner>) {
    outer.flat_map(|i| i.into_iter().map(|v| v));
}

struct Inner;

impl Inner {
    fn into_iter(self) -> impl Iterator<Item = ()> {
        iter::empty()
    }
}