如何用单个for<'a>约束覆盖多泛型的高阶Trait Bounds？

原始代码 #

struct Source<'a> {
    content: &'a str,
}

struct Final<'a> {
    content: &'a str,
}

struct Intermediary<'a> {
    content: &'a str,
}

impl<'a> From<Intermediary<'a>> for Final<'a> {
    fn from(intermediary: Intermediary<'a>) -> Self {
        Final { content: intermediary.content }
    }
}

fn example<F, C>(f: F)
where
    for<'a> F: FnOnce(Source<'a>) -> C,
    for<'a> C: Into<Final<'a>>,
{
    // implementation details
}

fn call() {
    example(|source| {
        Intermediary { content: source.content }
    });
}

编译错误 #

error: lifetime may not live long enough
  --> src/main.rs:51:9
   |
50 |     example(|source| {
   |              ------- return type of closure is Intermediary<'2>
   |              |
   |              has type `Source<'1>`
51 |         Intermediary { content: source.content }
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`

问题分析 #

你的判断完全正确——原始代码中F和C的for<'a>约束是独立的：C被要求对所有生命周期'a都实现Into<Final<'a>>，但闭包返回的Intermediary<'a>只和输入的Source<'a>生命周期绑定，仅能对这个特定的'a完成转换，无法满足“适配所有生命周期”的苛刻要求，这才引发了生命周期不匹配的错误。

解决方案 #

要让F的返回类型与输入的Source<'a>生命周期绑定在同一个for<'a>约束里，不需要单独将C作为泛型参数，直接把Into<Final<'a>>的约束合并到F的闭包返回类型上即可：

简洁实现方式

修改后的example函数：

fn example<F>(f: F)
where
    for<'a> F: FnOnce(Source<'a>) -> impl Into<Final<'a>>,
{
    // implementation details
}

显式关联类型方式（适合需复用返回类型的场景）

fn example<F, C>(f: F)
where
    for<'a> F: FnOnce(Source<'a>) -> C<'a>,
    for<'a> C<'a>: Into<Final<'a>>,
{
    // implementation details
}

修改后完整可编译代码 #

struct Source<'a> {
    content: &'a str,
}

struct Final<'a> {
    content: &'a str,
}

struct Intermediary<'a> {
    content: &'a str,
}

impl<'a> From<Intermediary<'a>> for Final<'a> {
    fn from(intermediary: Intermediary<'a>) -> Self {
        Final { content: intermediary.content }
    }
}

fn example<F>(f: F)
where
    for<'a> F: FnOnce(Source<'a>) -> impl Into<Final<'a>>,
{
    // implementation details
}

fn call() {
    example(|source| {
        Intermediary { content: source.content }
    });
}

这段代码可以正常编译，因为现在闭包返回的Intermediary<'a>只需要适配当前输入Source<'a>对应的生命周期，完全符合你定义的From实现逻辑。

内容的提问来源于stack exchange，提问作者Ymi_Yugy