Static Lifetime

The 'static lifetime is a reserved lifetime specifier in Rust indicating that a value or reference is valid for the entire duration of a program’s execution. It represents the longest possible lifetime and acts as the absolute upper bound in Rust’s borrow checker hierarchy.

In Rust, 'static manifests in two distinct semantic contexts: as a reference lifetime and as a trait bound.

1. Reference Lifetime (&'static T)

When applied to a reference, &'static T guarantees that the data being pointed to will never be dropped or invalidated while the program is running. The data resides in memory that is guaranteed to persist.

This occurs mechanically in three ways:

Read-Only Data Segment: Data baked directly into the compiled binary (such as the .rodata section) inherently possesses a 'static lifetime.

// String literals are inherently &'static str
let literal: &'static str = "compiled into the binary";

Global Variables: Items declared with the static keyword are evaluated at compile time, stored in a fixed memory location, and exist globally.

static CONFIG_FLAG: bool = true;
let flag_ref: &'static bool = &CONFIG_FLAG;

Heap Leaking: Dynamically allocated heap memory can be intentionally stripped of its owner, bypassing the Drop implementation. This prevents deallocation and promotes the resulting reference to 'static.

let heap_string = String::from("dynamic data");
// Box::leak consumes the Box and returns a &'static mut T
let static_ref: &'static mut str = Box::leak(heap_string.into_boxed_str());

2. Trait Bound (T: 'static)

When used as a generic constraint, T: 'static does not mean the value must live for the entire program. Instead, it dictates that the type T must not contain any non-static borrowed data. It expresses that the type can live indefinitely if the program chooses to hold onto it.

A type satisfies the T: 'static bound if:

1. It is a fully owned type (e.g., String, i32, Vec<u8>).
2. It only contains references that are themselves &'static.

fn require_static_bound<T: 'static>(value: T) {
    // 'value' can be dropped at the end of this scope.
    // The bound only guarantees 'value' doesn't contain short-lived references.
}

let owned_string = String::from("owned");
require_static_bound(owned_string); // Compiles: String is an owned type, containing no references.

let local_int = 5;
let local_ref = &local_int;
// require_static_bound(local_ref); // Fails: local_ref is bounded by the local scope, not 'static.

Coercion and Subtyping

Because 'static outlives all other lifetimes, Rust’s lifetime subtyping rules ('static : 'a) allow a &'static T to be safely coerced into any shorter lifetime &'a T. The compiler will automatically shrink a 'static reference to fit the required scope of a function signature or struct definition.

fn expects_short_lifetime<'a>(s: &'a str) {}

let static_str: &'static str = "always valid";
expects_short_lifetime(static_str); // The compiler coerces &'static str to &'a str

Master Rust with Deep Grasping Methodology!

Learn More