结合Rust生命周期类型说说协变/逆变

• Rust 中可以说一切皆类型。

• Rust 又面向表达式，每个表达式都会产生某种类型。

• 整个 Rust 代码就是表达式产生类型，再进行类型转换的大集合。

• 基于这个大的类型集合，就可以做类型检查推断，借用检查，从而实现所有权机制。

子类型 subtyping

变化性 Variance

• 协变 covariance: 若 B ≤ A ，能推出 f(B) ≤ f(A); 则称 A 在 f 上产生了协变，或者称 f(A) 是 A 的协变体。即在 f 作用后的新群中，依然保持着和原始集合相同的集合序：B ≤ A ⇒ f(B) ≤ f(A) ，此时有 f(B) 可以替代 f(A)。

• 逆变 cotravariance: 若 B ≤ A ，能推出 f(A) ≤ f(B); 则称 A 在 f 上产生了逆变，或者称 f(A) 是 A 的逆变体。在 f 作用后，产生了相反的集合序：B ≤ A ⇒ f(A) ≤ f(B) ，此时有 f(A) 可以替代 f(B)。刚好和原集合序：B 可以替代 A 相反。

• 不变 invariance: 既不是协变，也不是逆变；子类型系统不存在任何联系，即 f(A) ∩ f(B) = ∅。

List<A> // f表示: List

fn (a: &'a mut A); // f表示：fn(&'a) 这个函数签名，后文还会提到

Rust 生命周期子类型系统上的变化性

fn s1_or_s2<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let ret;
    {
        // 某处代码作用域
        let s1 = String::from("hello");
        let s2 = String::from("world");
        ret = s1_or_s2(&s1, &s2); // 编译报错❌

        // s1, s2 即将超出作用域，堆内存 hello 和 world 都将被释放
    }
    ret; // ret 变为悬垂指针
}

'long <= 'short; // 实际代码中往往是 'static <= 'a

fn s1_or_s2<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let ret;
    let s1: &'static str = "hello"; // s1 为 'static 作用域
    {
        let s2 = String::from("world");
        let s2 = &s2; // &s2 编译报错❌，因为 s2 在 {} 之后就被会被释放
        ret = s1_or_s2(s1, s2);
    }
    println!("{ret}");
}

fn s1_or_s2<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let ret;
    let s1: &'static str = "hello"; // s1 为 'static 作用域
    {
        let s2 = String::from("world");
        let s2 = &s2; 
        ret = s1_or_s2(s1, s2);
        println!("{ret}"); // ✅ 正确输出 world
    }
}

• ‘static ≤ ‘a 所以 ‘static 是 ‘a 的子类型，即‘static 可以替代 ‘a 。

• 上述示例中，实际的映射体是 &’a str 即 f(’a) = &'a str ⇒ f = & str我们用泛型参数 T 来表示 str 即表示为：&’a T 。

• Rust 在 &’a T 上即支持 ‘a 的协变，也支持 T 的协变。

• 结论：’static ≤ ‘a 经过 f = & str 的映射后，依然有：&'static str ≤ &‘a str ，即&'static str 可以替代 &’a str 。

fn main() {
    let ret;
    let s1: &'static str = "hello"; // s1 为 'static 作用域
    {
        let s2 = String::from("world");
        let s2 = &s2; 
        ret = s1_or_s2(s1, s2); // s2 报错，存活的不够长，作用域为 'b
    }
    println!("{ret}");
}

fn main() {
    let ret;
    'static: { // 'static 作用域
        let s1: &'static str = "hello"; // s1 为 'static 作用域
        'a: { // 'a 作用域
            'b: { // 'b 作用域
                let s2 = String::from("world");
                let s2 = &'b s2; 
                ret = s1_or_s2(s1, s2); // s2 报错，存活的不够长，作用域为 'b
            }
            // 在 'a 作用域下打印了 ret
            println!("{ret}");
        }
    }
}

• s1 是 &’static str ，传给了s1_or_s2 函数的第一个参数，该参数类型为 &’a str

• 由于 ‘a 支持在 & str 下的协变，即依然有：&’static str ≤ &’a str

• 所以有 &’static str 可以替代 &’a str 。所以 s1 传入符合协变规则。✅

• s2 为 &’b str 类型，

• 由协变规则，&’a str ≤ &’b str ，即 &’a str 可以替代 &’b str ，但是反过来不可以。

• 而代码 s1_or_s2(s1, s2) 的 s2 赋值就是违反了规则，试图用 &’b str 替代 &’a str 导致报错❌。事实上如何这被允许，就变为了逆变规则。

你可能在其他地方看到，函数的入参支持逆变，返回值支持协变。笼统的讲，是这么回事，但并不是说函数入参这个类型本身是逆变的。协变/逆变是对类型而言的，和什么地方的参数没有关系。Rust 允许这个函数指针类型对原来类型做逆变，注意是函数指针，也就是说把整个函数签名作为一种类型，这个函数签名对入参类型 T，支持了逆变；对返回值类型 U 支持了协变。这部分后文会展开做深入讨论。

fn main() {
    // b1 为 &'static str 类型
    let b1: Box<&'static str> = Box::new("hello");
    { // 'a 作用域
        // b2 为: &'a str 作用域类型
        let mut b2: Box<&str>;
        // 由于 'static <= 'a; 'a 支持对 &'a T 的协变，所以 &'static str <= &'a str
        b2 = b1;
    }
}

• covariant 表示协变体，例如 &'a T 是 ‘a 的协变体，也是 T 的协变体。前一个代码示例已经验证了这个问题

• contravariant 表示逆变体，Rust 中唯一支持逆变的地方就是函数指针作用在某种类型 T 上的时候，且 T 为函数入参时候，该函数指针类型所发生的逆变；即 fn(T) → U 这个整体是 T 的逆变体，是 U 的协变体。注意，Rust 中一切皆类型，fn(T) → U 整体也是一个类型。按照数学上的群映射，f(T) = fn(T) → U ，这里的 f = fn() → U ；注意把握这一点。

函数签名的入参逆变和返回值协变

fn get_str() -> &'a str;

fn get_static() -> &'static str;

• ‘static ≤ ‘a ，即 ‘static 可以替代 ‘a。

• 得出: fn() -> &'static str ≤ fn() -> &'a str 成立，即 fn() -> &'static str 可以替代 fn() -> &'a str 的函数签名。

• 所以是 fn() -> &'a str 是 &‘a str 的协变体。

• 另 &‘a str = U 。所以 fn() → U 是 U 的协变体。

fn store_ref(&'a str);

fn store_static(&'static str);

• ‘static ≤ ‘a ，即 ‘static 可以替代 ‘a。

• 得到：fn store_ref(&'a str) ≤ fn store_static(&'static str)

• 所以 fn(&’a) 是 ‘a 的逆变体。

fn static_print(input: &'static str) {
    println!("{:?}", input);
}

fn a_print<'a>(input: &'a str) {
    println!("{:?}", input);
}

fn main() {
    let static_fp: fn(&'static str);
    let a_fp: for <'a> fn(&'a str);

		// a_print 是一个 fn(&'a str) 类型，可以成功赋值给 fn(&'static str)
    // 即 
    static_fp = a_print;
    a_fp = static_print; // 编译错误❌
}

--> src/main.rs:14:12
   |
14 |     a_fp = static_print;
   |            ^^^^^^^^^^^^ one type is more general than the other
   |
   = note: expected fn pointer `for<'a> fn(&'a str)`
                 found fn item `fn(&'static str) {static_print}`

use std::cell::RefCell;

thread_local! {
    // StaticVecs 显然是 static 生命周期
    pub static StaticVecs: RefCell<Vec<&'static str>> = RefCell::new(Vec::new());
}

/// 由于 StaticVecs 显然是 static 生命周期
/// 所以 input 必须是 static 生命周期
fn store(input: &'static str) {
    StaticVecs.with(|v| {
        v.borrow_mut().push(input);
    })
}

/// 'a 限定了 input 和 f 的参数必须是相同的生命周期
fn demo<'a>(input: &'a str, f: fn(&'a str)) {
    f(input);
}

fn main() {
    demo("hello", store); 
    // "hello" 是 'static. 第二个参数也会被认为是 fn(&'static str)，匹配；✅执行

    {
        let smuggle = String::from("smuggle");
        demo(&smuggle, store); // 编译报错 ❌
    }

    StaticVecs.with(|v| {
        println!("{:?}", v.borrow()); // use after free 😿
    });
}

fn main() {
    demo("hello", store); 
    {
        //...
    }
}

fn main() {
    // ...
    'a: {
        let smuggle = String::from("smuggle");
        demo(&smuggle, store); // 编译报错 ❌
    }
    // ...
}