First vs second lifetime annotation in impl


I know this is covered in the book somewhere but I couldn’t find it at a glance…

When defining lifetimes on an impl, what is the difference between the first and the second lifetime annotation?

I mean, something like this is everywhere, but I don’t know the difference between the two 'a's:

impl <'a> Foo for Bar <'a> { ...}


Here the link into the rust book.


Oh - thanks… so the first is like the declaration of the generic, and the second is the actual bound for the trait?


Yes it’s about that. After that does not serve often. These are very specific cases but when we fall on it we are happy to know.


The first 'a represents a generic lifetime (parameter), it will assume a certain lifetime that can be constrained by where: conditions.
The second 'a represents a generic argument, a hole that’s filled with the concrete lifetime that the former 'a assumes on instantiation of the block, basically.
Instantiation is maybe not the correct word, but I use it to convey “filling in all generic parameters”.

Since the lifetime parameter is defined on the impl block, all implemented methods can use a generic argument (with the same name) to reference the concrete lifetime. The concrete lifetime will come from the calling context.
In this case Bar<'a>; 'a is a lifetime used within the Bar struct. This implies that the lifetime 'a will outlive the structure itself. This can be expressed as a constraint and is implicitly added by the compiler:

'a: Bar<'a>, = 'a: Self, -> 'a outlives Bar<'a>
equivalent to
lifetime 'a has the same-or-bigger scope than the instantiation of Bar<'a>.

Example code:

In Rust, everything has a lifetime.
When working with generics it’s necessary to keep track of a certain lifetime so the compiler can verify soundness. That’s where generic lifetime parameters come into play.

Edit: I had the bounds the other way around. Outlives relationship is defined as 'longer: 'shorter, see