Rust 是否会缩小生命周期以满足定义在其上的约束？

Question

请考虑这个例子 (playground):

struct Container<'short, 'long: 'short, T: 'long> {
    short_prop: &'short u8,
    long_prop: &'long T,
}

fn main() {
    let value = 9;
    let long = &value;

    {
        let short = &value;
        let res = Container {
            short_prop: long,
            long_prop: short, // why is this not an error?
        };

        println!("{} {}", res.short_prop, res.long_prop);
    }
}

在 Container 中我指定 'long: 'short 我假设意味着 'long 应该至少活到 [=14] =].在 main 中，变量 long 的寿命应该比 short 长，因为它的范围更大。

所以 Container 期望进入 long_prop 的任何东西至少与进入 short_prop 的东西一样长。然而，编译器对我将生命周期较长的 long 传递给 short_prop 并将生命周期较短的 short 传递给 long_prop.

非常满意

这是因为在 Container 的实例化时，编译器将 long 的生命周期缩小为等于 short 的生命周期，从而满足 'long: 'short 约束（因为生命平等很好）？还是另有原因？

Answer 1

Is this because at the instantiation of Container the compiler narrows the lifetime of 'long to be equal to the lifetime of 'short thus satisfying the 'long: 'short constraint (since equality of lifetimes is fine)?

是的。

Or is there another reason?

没有。

这是一个更简单的 Container 结构的示例，它一次只包含 1 个引用。它可以同时保存 long 和 short 引用的原因是因为较长的生命周期是较短生命周期的子类型，但是 container 变量的总生命周期被缩小到这两者的最小重叠lifetimes，这意味着 container 与 short 同时超出范围：

#[derive(Debug)]
struct Container<'a> {
    some_ref: &'a str
}

fn main() {
    let long = String::from("long");
    let long_ref = &long;
    
    let mut container = Container {
        some_ref: long_ref,
    };
    
    dbg!(&container);

    {
        let short = String::from("short");
        let short_ref = &short;

        container.some_ref = short_ref;

        dbg!(&container);
    } // both short & container go out of scope here
    
    dbg!(&container); // error, container dropped in block above, has same lifetime as short
}

playground

Rust 是否会缩小生命周期以满足定义在其上的约束？

Does Rust narrow lifetimes to satisfy constraints defined on them?

reference

lifetime

rust

borrow-checker

borrowing