Do non-reference types always satisfy a lifetime of 'static?

Question

I'm trying to understand why the code below compiles. I wasn't expecting to be able to construct Wrapper<String> since T: 'static and runtime-allocated strings don't live for the entire lifetime of the program.

I think the reason this is allowed is because I'm setting T to a non-reference type (String). When I use a &str, or a struct containing a reference, the compiler issues the error I'd expect.

However, I haven't been able to find anything in the Rust docs that confirms my hypothesis, so maybe I don't fully understand the rules. Will all non-reference types satisfy the 'static lifetime bound on Wrapper<T>, or are there some that will fail?

use rand::Rng;

struct Wrapper<T>
where
    T: 'static,
{
    value: T,
}

fn wrap_string() -> Wrapper<String> {
    // Use rng to avoid construcing string at compile time
    let mut rng = rand::thread_rng();
    let n: u8 = rng.gen();
    let text = format!("The number is {}", n);
    Wrapper { value: text }
}

fn main() {
    let wrapped = wrap_string();
    std::mem::drop(wrapped);
}

It looks like your question might be answered by the (duplicate) answers of [What does the 'static lifetime mean in a trait bound in a Rust future?](https://stackoverflow.com/q/48504103/155423). If not, please **[edit]** your question to explain the differences. Otherwise, we can mark this question as already answered. — Shepmaster, Sep 17 '19 at 19:36
I think this question is more specifically asking why a type which doesn't have a static lifetime would still satisfy the bound `T: 'static`. That seems different to the more general questions asked in the linked question and the ones it's marked as a duplicate of. (FWIW, I couldn't work out the answer to this question just by reading those answers.) — Alistair, Sep 18 '19 at 07:11

Alistair · Accepted Answer · 2019-09-18T07:14:21.977

From the Background section of RFC 2093:

[...] in order for a reference type &'a T to be "well formed" (valid), the compiler must know that the type T "outlives" the lifetime 'a -- meaning that all references contained in the type T must be valid for the lifetime 'a. So, for example, the type i32 outlives any lifetime, including 'static, since it has no references at all.

So I'd say the answer to your question is: yes, any type which has no references (or which only contains static references) satisfies the 'static bound.

Side note: according to that RFC, bounds like T: 'static and T: 'a are known as outlives requirements.

score 3 · Answer 2 · answered Sep 18 '19 at 07:21

You can think of a type bound T: 'x as "Instances of T cannot suddenly become invalid because something that lives shorter than 'x was dropped.". However, this does not affect how long the instance of T itself lives.

So, a reference becomes invalid if the referenced thing is dropped. Which means that the referenced thing must live at least as long as 'x - for the entire run of the program in the case of 'static.

But something that own all its data - an i32 or a String for example - never becomes invalid because something else is dropped. An integer is good until it is dropped itself. So it satisfies the 'static bound.

Do non-reference types always satisfy a lifetime of 'static?

2 Answers2