协变、逆变和不变#

我们知道了仅有生命周期不同的类型间可以讨论继承关系，于是就有了协变、逆变和不变之说。它们的意思非常简单：

假设我们有一个接收类型 T 的泛型类型 C<T>，那么

1. 协变：如果 T1 是 T2 的子类型，我们可以断言 C<T1> 也是 C<T2> 的子类型
2. 逆变：如果 T1 是 T2 的子类型，我们可以断言 C<T2> 是 C<T1> 的子类型
3. 不变：无论 T1 和 T2 的关系为何，我们都不能断定 C<T1> 和 C<T2> 的关系

这里的“泛型类型”外延比我们习惯称呼的那些要大得多：

• 常见的 struct Foo<T> 当然算泛型类型
• &mut T 也算一个接收 T 的泛型类型，这里的 C 可以看作 &mut
• fn() -> T 是一个返回 T 的泛型类型

总而言之，任何需要提供一个 T 补完的类型都可以看作“泛型类型”。

对不同的泛型类型 rust 有不同的变化规则

1. 标准库的容器类型 Box<T> 和 Vec<T> 是协变的。举个例子，如果 T 分别是 &'a _ 和 &'b _，且'a: 'b，那么 Box<&'a _> 也是 Box<&'b _> 的子类型，前者可以用于任何需要后者的地方。可以简单理解为给生命周期套个容器的壳，它们之间的大小关系不变。

2. fn(T)-> _ 是逆变的，或者说“函数对入参是逆变的”。如果一个地方要求函数的入参是 'a，那么任何入参要求小于 'a 的函数也能用。一个极端点的例子是如果调用者允许函数签名是fn(&'static _)，那么给它一个 fn<'a>(&'a _) 也可以，毕竟前者对入参的要求比后者强得多。

3. fn(_)-> T 是协变的，或者说“函数对返回值是协变的”。当调用这希望函数是 fn<'a>() -> 'a _ 时，给出一个 fn() -> 'static _ 是安全的。因为返回值上生命周期更长的话，函数对调用者的约束就更少，如果调用者能适应更强的约束（即更短的返回值生命周期），那么当然可以给一个更长生命周期的返回值。

4. &T 是协变的，&'a &'long _ 是 &'a &'long _ 的子类型，这应该是显然的。

5. &mut T 是不变的。无论 'a，'b 的关系为何，&mut &'a _ 和 &mut &'b _ 都无法互相替代。 首先，它肯定不能是逆变，不然把 &mut &'short 当成 &mut &'long 一解引用程序和工作可能一起没了。 而如果是协变的话，我们可以用可变引用给一些 'long 的类型塞一些 'short 的东西进去：

fn evil(v: &mut Vec<&'static str>) {
    let short: &mut Vec<&'_ str> = v; // 既然是协变，那么 &mut Vec<&'static _> 代替 &mut Vec<&'short _>传给 short 很合理吧
    short.push("temp".to_string()); // 这安全吗？
}

6. 基于和4/5类似的理由，*const T 对 T 是协变的，*mut T/UnsafeCell<T> 对 T 是不变的。

用户自定义类型的情况取决于其字段是什么，规则是：

1. 如果所有使用 T 的字段对 T 都是协变的，那么整个类型对T是协变的
2. 如果所有使用 T 的字段对 T 都是逆变的，那么整个类型对T是逆变的
3. 其余情况均为不变

高阶生命周期#

高阶生命周期（Higher-Rank Trait Bounds）是为了解决生命周期作为模板参数时存在的局限性。我们知道 rust 会将模板函数或类型进行单例化，但当生命周期作为模板参数时，会导致一种奇怪的结果

let pass = |_: &i32| ();
let reject = |_| ();
{
    let x = 1i32; // 假设 x 的生命周期是 '1
    pass(&x);
    reject(&x);
}
let y = 2i32; // 假设 y 的生命周期是 '2
pass(&y);
// 取消下面这行的注释，会得到一个错误
// reject(&y);

rust-analyzer会提示 pass 和 reject 的类型都是 impl Fn(&i32)，但是 reject 就是无法用两次。

区别在于生命周期标注其实是不一样的：

• pass: for<'a> Fn(&'a i32)
• reject: Fn<'a>(&'a i32)

for<'a> 表示对于“所有可能的 'a”，相对地，reject 的类型表示就是“只针对特定的'a”。其区别正如代码所展示的： 在花括号内，rust 会确定 reject 的 'a 正是 '_1 （注意 reject 是个“变量”，所以它应该有具体的类型而不是什么模板），因而 reject 的类型就被固定为 Fn(&'_1 i32)。 第二次传入了一个 &'_2 i32 且由于此类型不是 &'_1 i32 的子类型，当然无法编译成功。

相反，pass 的类型允许传入“所有可能的” 'a，从而解决了 reject 的问题。rustc 在这里使用的技术称为“晚绑定”（later binding），顾名思义，就是在第一次被调用时先不急着确定其具体类型，在后面再来确定。 之所以省略类型标注就变成 reject 的类型了，也是因为无法保证类型推断发生的时间比晚绑定更早，因而需要做完整类型推断的类型不会参与晚绑定（不完整的类型推断是指 |_:&_|() 这样的声明方式）。类似的事情除了晚绑定，还会发生在 coerce 身上，不过那和生命周期关系不大，暂且不表。

对于程序员而言，可能用到HRTB的地方也往往涉及到带引用的闭包：

fn call_closure<'a, F>(callback: F) where F: Fn(&'a str, &'a str)->&'a str {
    let s1 = "Hello".to_string();
    let s2 = "World".to_string();
    callback(&s1, &s2);
}

这里 F 的类型要求手动标注生命周期，但是 'a 这个标注出现在函数的模板参数里，意味着它是一个比 call_closure 长的生命周期，函数内的 s1、s2 的生命周期则不能超出 call_closure，因而rust会拒绝把 s1 和 s2 传递给 callback。 这时就需要改成

fn call_closure<F>(callback: F) where F: for<'a> Fn(&'a str, &'a str)->&'a str {
    let s1 = "Hello".to_string();
    let s2 = "World".to_string();
    callback(&s1, &s2);
}

’static#

'static作为生命周期讲的时候意味着整个程序运行期间都存活。显然，&'staitc T是任意 &T 的子类型。

当'static出现在trait中时，则意味着实现该trait的类型要么不含引用，要么所有引用都是'static的。

擦除生命周期#

Rust中的指针是不含生命周期的，这意味着一个&'a T转成*const T后可以继续转为&'static T，无疑这是一个相当容易不安全的操作。

在下一代借用检查器Polonius就绪之前，却可以利用这个性质小小地开个洞

fn get_default<'r, K: Hash + Eq + Copy, V: Default>(
    map: &'r mut HashMap<K, V>,
    key: K,
) -> &'r mut V {
    // 转成指针绕过None分支里的借用检查
    let p_map = map as *mut _;
    match map.get_mut(&key) {
        Some(value) => value, 
        None => {
            let map: &mut HashMap<K, V> = unsafe { &mut *p_map };
            map.insert(key, V::default());
            map.get_mut(&key).unwrap()
        } 
    } 
}

Polonius之前的借用检查器会认为map在Some分支里已经被借用了，所以在None分支里不能再用。而因为指针是不携带生命周期的，在None分支里可以用它再转回引用。

PhantomData#

既然指针不含生命周期，那么下面这样的结构就很容易被用出问题

struct Slice<T> {
    start: *const T,
    end: *const T,
}

作为一个Slice，它理应是对某段数据的引用，具有某个特定的生命周期，然而这样的类型声明里并没有体现出这一点，完全被视为了Owned类型。但是它确实每个字段上又不需要生命周期标注，我们不能加一个没用过的生命周期标注上去。

这时就轮到PhantomData出场了，PhantomData的作用是让这个结构体“好像有这个字段一样”。

struct Slice<'a, T> {
    start: *const T,
    end: *const T,
    _phantom: PhantomData<&'a T>,
}

因为“好像有这个字段”，所以编译器在做静态分析时会认为Slice真的有&'a T,从而合适地为它分配一个生命周期参数。当然实际上在运行中这个字段没有任何作用，不产生任何运行时开销。

PhantomData的意义就是让类型在静态检查面前表现得像有这个类型。例如

struct NotSend {
    data: i32,
    // 静态检查认为此类型包含*const u8，所以不是Send类型
    // 在不能用!Send标记的时候有用
    _phantom: PhantomData<*const u8>
}

struct Invariant<T> {
    data: Vec<T>,
    // 静态检查认为此类型包含UnsafeCell<T>，所以对T是不变的。
    _phantom: PhantomData<UnsafeCell<T>>
}

may_dangle#

当某个结构体携带了生命周期标注，同时又手动实现了Drop时，可能会发生生命周期错误。

struct RefData<'a> {
    buf:&'a [u8]
}
struct Data<'a> {
    ref_buf:Option<RefData<'a>>
    data: Box<[u8]>
}

fn main() {
    let mut data = Data {ref_buf: None, data: Box::new([1,2,3])};
    data.ref_buf = Some(RefData{buf: &data.data});
}

这是合法的rust代码，Data和RefData确实被实例化成了相同的生命周期。然而如果给RefData添加了手动的Drop实现rustc就会立刻报错。

原因是现在的rustc并不会细致地去检查Drop的内部实现，程序员在Drop函数内可以先销毁Data::data再销毁Data::ref_buf，如果在销毁Data::data调用了Data::ref_buf，显然就是一个内存错误。 故而rust采取了“宁杀错勿放过”的态度。如果程序员确认自己在Drop内的实现没有产生生命周期问题，可以用#[may_dangle]标注。

use<‘a>#

Rust的RPIT（Return Position Impl Trait）特性可能会引入一类生命周期错误。

fn process_stream<'a>(ctx:&'a Context, data: Vec<Data>) -> impl Iterator<Item=Result> {
    data.into_iter().map(|datum| ctx.process(datum))
}

这个代码在2024版之前是编不过的，因为闭包捕获了ctx，我们当然应该要求返回类型也具有'a的生命周期，此时编译器会提示我们在返回类型后加上'a。然而问题在于，一旦我们写出impl Iterator<Item=Result> + 'a，rustc会认为Data也需要outlive 'a。在rustc看来，这个返回值类型是从Data的迭代器派生而来的，Data在这里就是impl Iterator<Item=Result>的隐藏类型，任何加在impl Trait上的约束都会施加在Data上。

总之，这种代码的问题在于我们期望返回的迭代器形式应该是

struct Iter<'a> {
    ctx: &'a Context,
    data: Vec<Data>
}

但是默认情况下RPIT不会捕获生命周期参数，它生成的类型类似于

struct Iter {
    ctx: &Context,
    data: Vec<Data>
}

无疑，这个类型是不合法的，需要加上生命周期标注，然而一旦手动写成了impl ... + 'a的形式，+ 后面的生命周期会对整个类型起效：

struct Iter<'a> {
    ctx: &'a Context,
    data: Vec<Data<'a>>
}

这当然并非我们所期望的。

在2024版之后，RPIT将会自动捕获包括生命周期在内的所有泛型参数，而不仅仅是类型泛型参数。这意味着2024版之后我们无需写+ 'a，编译器会自动认为返回类型需要活得比'a长，当然这和Data无关。

这种新的默认行为会带来另一种问题，

fn iter_range<'a>(slice: &'a[u8])-> impl Iterator<usize> {
    0..slice.len()
}

因为默认情况下会捕获所有生命周期泛型参数，这么写的话编译器会认为返回值类型需要 outlive 'a，但实际上并不需要，毕竟我们只是立刻获取了slice的长度信息，在迭代过程中不需要再借用slice了。为此需要使用use语法显示指定需要捕获的泛型参数：

fn iter_range<'a>(slice: &'a[u8])-> impl Iterator<usize> + use<> {
    0..slice.len()
}

因为没有要捕获的参数，所以只写use<>就可以————理想的写法是这样，但编译器尚未支持空use的写法（#130043）。一种临时解决方案是

fn iter_range<'a>(slice: &'a[u8])-> impl Iterator<usize> + 'static {
    0..slice.len()
}

'static意味着返回值类型不捕获任何生命周期泛型参数。