你的问题有两种解决方案.让我们从最简单的一个开始:

Add a lifetime to your trait

trait Foo<'a> {
    type Item: AsRef<Path>;
    type Iter: Iterator<Item = Self::Item>;
    
    fn get(&'a self) -> Self::Iter;
}

这就要求你在使用该特征的任何地方都要标注生命周期.当你实现trait时，你需要做一个通用的实现:

impl<'a> Foo<'a> for Bar {
    type Item = &'a PathBuf;
    type Iter = std::slice::Iter<'a, PathBuf>;
    
    fn get(&'a self) -> Self::Iter {
        self.v.iter()
    }
}

当泛型参数需要trait时，还需要确保对trait对象的任何引用都具有相同的生存期:

fn fooget<'a, T: Foo<'a>>(foo: &'a T) {}

Implement the trait for a reference to your type

与其为你的类型实现trait，不如为你的类型实现trait.这种trait 永远不需要通过这种方式了解任何关于生命的信息.

然后，trait函数必须按值获取其参数.在您的情况下，您将实施以下特征作为参考:

trait Foo {
    type Item: AsRef<Path>;
    type Iter: Iterator<Item = Self::Item>;
    
    fn get(self) -> Self::Iter;
}

impl<'a> Foo for &'a Bar {
    type Item = &'a PathBuf;
    type Iter = std::slice::Iter<'a, PathBuf>;
    
    fn get(self) -> Self::Iter {
        self.v.iter()
    }
}

你的fooget函数现在变得简单了

fn fooget<T: Foo>(foo: T) {}

问题是fooget函数不知道T实际上是&Bar.当您调用get函数时，实际上是从foo变量中移出.你没有移出对象，你只是移动了引用.如果fooget函数try 调用get两次，该函数将无法编译.

如果希望fooget函数只接受Foo trait用于引用的参数，则需要显式声明以下界限:

fn fooget_twice<'a, T>(foo: &'a T)
where
    &'a T: Foo,
{}

where子句确保只为引用调用此函数，其中Foo是为引用而不是类型实现的.这两种方法也可以同时实施.

从技术上讲，编译器可以自动推断fooget_twice年内的生存期，因此您可以将其编写为

fn fooget_twice<T>(foo: &T)
where
    &T: Foo,
{}

但这还不够聪明.

对于更复杂的情况，可以使用尚未实现的Rust 功能:Generic Associated Types(GATs).issue 44265年正在追踪这方面的工作.