What Is Lifetime Subtyping in Rust?

Lifetime subtyping in Rust is the compiler's enforcement that a reference's lifetime must be at least as long as any other lifetime it is used with, ensuring memory safety without garbage collection. The borrow checker uses this rule to prevent dangling references by verifying that a longer-lived reference can be safely treated as a shorter-lived one, but not vice versa.

fn longest<'a, 'b: 'a>(x: &'a str, y: &'b str) -> &'a str {
    // 'b must outlive 'a, so we can return x safely
    x
}

This constraint 'b: 'a means the lifetime 'b is a subtype of 'a (it lives longer), allowing the function to return a reference with the shorter lifetime 'a.

Lifetime subtyping is a rule that ensures a piece of data lives long enough to be safely used by a reference. Think of it like a library book: if you promise to return a book by Friday, you can also promise to return it by Monday, but you cannot promise to return it by Monday if you actually need it until Friday. This prevents the compiler from allowing code that tries to use data after it has been deleted.