What is the significance of the name `'a` in all of Rust's reference lifetime annotation examples?

Question

All of Rust's documentation and third-party/blog examples (at least the top several results in Google) use <'a> to demonstrate lifetime annotations.

What is the significance of the name choice 'a?

• Is this a new de-facto convention like the old i in for(i=0; ...)?

• Do you use 'a in all the lifetime annotations in your production code?

• What are some real-world examples if lifetime scope names you have used in your own code?

Answer 1

There is no special significance to 'a. It's just the first letter of the Latin alphabet and, if you had more than one lifetime, you might name them 'a, 'b, 'c etc.

One reason that descriptive names are not commonly used for lifetime parameters is similar to why we often use single letters for type parameters. These parameters represent all possible types with the actual type left up to the caller. In generic contexts, the actual argument could be anything and often it's completely unconstrained, so naming it might imply that the usage is narrower than it actually is. For example the T in Option<T> means the type and it wouldn't make sense to be more specific than that.

That said, lifetimes are often connected to another type and it's not uncommon to name lifetimes to be a bit more obvious where they come from. For example, you could use 't to name the lifetime of a T parameter:

fn foo<'t, T: 't>(arg: T> {}

serde is an example of a popular library that does this. When a value is borrowed from data that is being deserialized, this is usually named 'de:

pub trait Deserialize<'de>: Sized {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>;
}

An example from my own work where I've named them more carefully is in a query language that searches over in-memory data structures. I used 'd to refer to values borrowed from the data being queried and 'q for values borrowed from the query itself.

Answer 2

'a is just the first letter of the alphabet, and easy to type. Yes, it's a stand-in similar to i when iterating of a range of numbers or x in almost any context. It's most similar to using T for a generic parameter.

It has become a de-factor convention to use 'a, 'b, etc as lifetime names, because it reduces the amount of visual space they take up. In cases where clarity is important, you'll see longer names, often matching the name of the field or generic parameter:

struct SomeStruct<'name, 'comment> {
    name: &'name str,
    comment: &'comment str,
}