Rust 更高级别的生命周期和泛型不能很好地发挥作用

在这里的代码中

trait Foo {
    type Output;
    fn foo(self) -> Self::Output;
}

impl<'a> Foo for &'a () {
    type Output = &'a ();
    fn foo(self) -> Self::Output {
        self
    }
}

fn func<F: Foo>(f: F) -> F::Output {
    f.foo()
}

fn func2<'a>(f: &'a ()) -> &'a () {
    func::<&'a ()>(f)
}

fn has_hrl<F: Fn(&()) -> &()>(f: F) {}

fn main() {
    //has_hrl(func); // FAILS
    has_hrl(func2);
    has_hrl(|x| func(x));
}

trait Foo{
类型输出；
fn foo（self）->self：：输出；
}
impl（f:&'a（））->&'a（）{
func:：在此表达式中：

has_hrl(func)

编译器被迫选择
func
的一个特定实例
func
在
F:Foo
上是泛型的，对于所有
'a
，
&'a（）
实现
Foo
，但编译器只能选择一个特定的
'a
来实例化
func
，因为类型变量不能表示多种类型。因此，
func:：Fn（&'a（））->&a（）
，它只实现
Fn（&'x（））->&x（）
一个特定的生命周期
'x

如果您声明
has_hrl
像
fn has_hrl&'a（）>（\uuf）{}
，这将起作用。但是，我的能力水平不足以解释为什么生命周期需要明确

这是因为原始声明有一个隐含的更高级别的生存期界限（这个界限相当于
F:for&'a（）
），这意味着
F
必须在所有的生存期
'a
实现
Fn（&'a（））->&'a（）
。您的版本只需要
F
就可以实现
Fn（&'a（））->&'a（）
一个具体的生命周期。如果
has_hrl
尝试使用
has_hrl
函数本地的生命周期调用闭包，您还会发现此版本不起作用，因为调用方不可能将该生命周期作为参数传递（这就是为什么引入了更高级别的生命周期界限）.
如果你声明
has_hrl
像
fn has_hrl&'a（）>（u:F{}
，这就行了。不过，我的能力水平不足以解释为什么生命周期需要显式。我只是尝试将语句
has_hrl（|x | func（x））；
分成两个语句：
让F=|x | func（x）；has_hrl（F）
同样的错误也出现了。以某种方式显示为参数的处理方式不同于变量绑定（绑定应该固定到完全具体的类型）。因此我猜Rust当前的类型系统还没有很好地捕获到更高级别的生存时间（并且在幕后使用了一些技巧）？我知道它有更高的生命周期，但我仍然不明白它为什么不起作用，似乎这是应该起作用的。@iopq：您的第一部分不太正确。编译器可以实例化单个
函数：：
对所有
'a
都有效。不幸的是，rustc似乎没有在类型中公开这一事实史蒂文：确实有一个
func:：