So, every reference has a lifetime. But writing them out all the time isn't great for humans. So we looked at existing code, and found that the vast majority of lifetimes followed a few simple patterns. So we implemented these patterns as "elision rules," that is, patterns where you can not write, that is, elide, the lifetime.

Here are the rules:

1. Every reference as a parameter gets its own lifetime parameter. There is only one in this case.

2. If there is exactly one, then every possible lifetime in the return type is assigned to it.

3. If there are multiple parameters, but it's a method, not a free function, then the lifetime assigned to self is assigned to all outputs.

This is written in a bit of an abstract way, but, #2 there describes this function: we have one input, so we assign the same lifetime to all outputs, and there's only one. This means that it's not 'static, and in fact, it would fail to compile if it assumed that.

The original RFC, if you're curious https://rust-lang.github.io/rfcs/0141-lifetime-elision.html

(And, I actually think there's been some tweaks over time; if you have no inputs, the outputs can turn into 'static... the core of it is these three things though. Oh yeah, that is in the reference, which is the up to date spec, https://doc.rust-lang.org/reference/lifetime-elision.html; I linked the RFC for historical reference because it's interesting, and has some neat stats.)