使用通用函数创建容器，向其添加项目，然后遍历项目时，值的使用寿命不够长

Question

我正在尝试编写一个创建默认值的泛型函数，并遍历其内部“缓冲区”。 所有这些都发生在没有参数的函数中，也没有返回值。 我似乎已经宣布生命周期不正确，我很难正确地设置它们以便工作。

下面是一个实现Default和IntoIterator特征的示例类型，以及一个需要一个方法的名为Foo的新特征。

trait Foo<T> {
    fn add(&mut self, T);
}

struct FooBar<T> {
    buf: Vec<Option<T>>,
    len: usize,
}

impl<T> FooBar<T> {
    fn new() -> Self {
        let buf = Vec::new();
        let len = 0;
        Self { buf, len }
    }

    fn iter(&self) -> FooBarIter<T> {
        FooBarIter { foo: self, pos: 0 }
    }
}

impl<T> Foo<T> for FooBar<T> {
    fn add(&mut self, val: T) {
        self.buf.push(Some(val));
        self.len += 1;
    }
}

impl<T> Default for FooBar<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<'a, T: 'a> IntoIterator for &'a FooBar<T> {
    type Item = &'a T;
    type IntoIter = FooBarIter<'a, T>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

FooBar只是为它拥有的向量添加值。 为了只允许非消耗迭代，我定义了一个迭代器，它借用底层Vec并在迭代期间维护“当前”索引，返回对消费者借用的每个元素的引用。

struct FooBarIter<'a, T: 'a> {
    foo: &'a FooBar<T>,
    pos: usize,
}

impl<'a, T> Iterator for FooBarIter<'a, T> {
    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.foo.len <= self.pos {
            return None;
        }

        self.pos += 1;
        self.foo.buf[self.pos - 1].as_ref()
    }
}

泛型函数创建一个默认值，添加一些项（类型为&str ），然后通过引用迭代它们。 我似乎已经宣布生命周期不正确，因为Rust抱怨说FooBar的借来的价值不够长。 然而，它说它一直存在到函数结束，所以我很担心Rust期望借用实际生活多久。

fn start<'a, T: 'a>()
where
    T: Foo<&'a str> + Default,
    &'a T: IntoIterator<Item = &'a &'a str>,
{
    let mut f = T::default();
    f.add("abcd");
    f.add("efgh");

    for val in &f {
        println!("{}", *val);
    }

    f.add("ijkl");

    for val in &f {
        println!("{}", *val);
    }
}

fn main() {
    start::<FooBar<&str>>();
}

这是一个错误，它指出&f寿命不够长，因为“借用的值只能存在”函数的结尾。

error[E0597]: `f` does not live long enough
  --> src/main.rs:70:17
   |
70 |     for val in &f {
   |                 ^ does not live long enough
...
73 | }
   | - borrowed value only lives until here
   |
note: borrowed value must be valid for the lifetime 'a as defined on the function body at 61:1...
  --> src/main.rs:61:1
   |
61 | / fn start<'a, T: 'a>()
62 | | where
63 | |     T: Foo<&'a str> + Default,
64 | |     &'a T: IntoIterator<Item = &'a &'a str>,
...  |
72 | |     }
73 | | }
   | |_^

我也尝试为&'a IntoIterator特性设置一个不同的生命周期参数，但是我最终&'a IntoIterator去寻找其他错误，而不是真正接近设置正确的生命周期。

为了进一步说明我想用FooBar实现的FooBar ，这里有一个例子，如果FooBar是Vec我正在尝试做什么。

fn start() {
    let mut f = Vec::new();
    f.push("abcd");
    f.push("efgh");

    for val in &f {
        println!("{}", *val);
    }

    f.push("ijkl");

    for val in &f {
        println!("{}", *val);
    }
}

我是否在试图找出生命周期参数的正确轨道上，还是完全不同于其他东西？

Answer 1

我相信你所尝试的目前是不可能的。

首先，您的错误消息是因为调用者在传递给start时指定了生命周期：

fn start<'a, T: 'a>()

这没有任何意义，因为调用者无法控制生命周期。 例如，如果调用是start::<Vec<&'static str>>但该函数创建了一些临时值？ 这个生命周期也与迭代器实现有关 - 如果对值的引用只要调用者指示，那么它就可以被迭代。

在许多类似的情况下， 排名较高的特质界限是解决方案，但是，我能得到的最接近的是有点不同：

trait Foo<T> {
    fn add(&mut self, T);
}

impl<T> Foo<T> for Vec<T> {
    fn add(&mut self, val: T) {
        self.push(val);
    }
}

fn start<T>()
where
    T: Default + Foo<&'static str>,
    for<'a> &'a T: IntoIterator,
    for<'a, 'b> &'a <&'b T as IntoIterator>::Item: std::fmt::Display,
{
    let mut f = T::default();
    f.add("abcd");
    f.add("efgh");

    for val in &f {
        println!("{}", &val);
    }

    f.add("ijkl");

    for val in &f {
        println!("{}", &val);
    }
}

fn main() {
    start::<Vec<&str>>();
}

主要的关键点是T: Default + Foo<&'static str> 。 就我所看到的而言，没有办法为T传递一个可以使用函数定义的HRTB的具体类型。 在这种情况下，我们可以使用'static 。 如果我们尝试使用for <'a> T: Default + Foo<&'a str> ，我们会收到错误：

error[E0277]: the trait bound `for<'a> std::vec::Vec<&str>: Foo<&'a str>` is not satisfied
  --> src/main.rs:33:5
   |
33 |     start::<Vec<&str>>();
   |     ^^^^^^^^^^^^^^^^^^ the trait `for<'a> Foo<&'a str>` is not implemented for `std::vec::Vec<&str>`
   |
   = help: the following implementations were found:
             <std::vec::Vec<T> as Foo<T>>
   = note: required by `start`

编译器不知道将在呼叫站点声明的生命周期与HRTB指定的生命周期相匹配。 我相信，但不确定， 通用关联类型可能会解决问题。

Answer 2

感谢Shepmaster指出我与HRTB正确的方向。 在阅读了这个主题后，我能够让函数本身提供FooBarIter和FooBarIter::Item的生命周期。 现在可以借用FooBarIter并持续到函数结束。 FooBar的生命周期仍然可以由调用者提供。

这是我最终编译所需的唯一变化。

fn start<'a, T>()
where
    T: Foo<&'a str> + Default,
    for<'b> &'b T: IntoIterator<Item = &'b &'a str>,
{
    let mut f = T::default();
    f.add("abcd");
    f.add("efgh");

    for val in &f {
        println!("{}", *val);
    }

    f.add("ijkl");

    for val in &f {
        println!("{}", *val);
    }
}