Question

我有一个方法make_iter()，该方法在Rust中使用多个适配器创建一个迭代器，可以简化为以下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，但我不知道如何。

请注意，不能更改结构实现。 Rust版本是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<_>>());
}

我知道唯一避免这种情况的方法是使用rental或owning_ref之类的板条箱。

另请参阅：

如果您有可能更改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()
    }
}

如何在Rust中延长迭代器适配器内部临时变量的寿命？

1 个答案: