Question about takeaway from drop_static<T: 'static>(t: T)

[maxim-ge]

Hi,

in the very interesting article Common Rust Lifetime Misconceptions you write:

A program to help illustrate these concepts:

use rand;

fn drop_static<T: 'static>(t: T) {
    std::mem::drop(t);
}

What you think about drop_static<'nonstatic, T: 'nonstatic>(t: T)?

It is compiled and run, too.

[pretzelhammer]

Can you please clarify your question? I'm not sure what you are asking. You can drop things which can live up to the end of the program, so you can certainly drop things which live shorter than that as well, so I'm not sure what the question here is.

[maxim-ge]

You claim that "T: 'static should be read as "T is bounded by a 'static lifetime". I think that it is just ignored by compiler in this case.

Another example:

fn print_static<T: 'static + std::fmt::Display>(t: T) {
    println!("{}", t);
}

fn main(){
    let s = String::from("Hello");
    print_static(s);
}

Or may be I'm wrong and s is bounded by static lifetime here?

[pretzelhammer]

s is bounded by 'static where the bound is an upper bound. s can be held indefinitely long, including up until the end of the program, but it also can be dropped earlier. It doesn't have to live as long as &'static T but it could if it wanted to. Does that help explain?

[maxim-ge]

Could you please give an example of the call to print_static that does not compile (because of lifetime incompatibility)?

[WaffleLapkin]

fn print_static<T: 'static + std::fmt::Display>(t: T) {
    println!("{}", t);
}

fn main(){
    let s = String::from("Hello");
    print_static(&s); // `&s` can't live till the end of the program, since `s` is dropped
}

[playground]

[maxim-ge]

@WaffleLapkin - thanks, now it is more clear