What is lifetime elision in very simple terms?

by

An item signature is the bit which gives the name and types of your function, i.e. everything you need to call it (without needing to know how it’s implemented); for example:

fn foo(x: u32) -> u32;

Here’s another which takes a &str reference:

fn bar<'a>(s: &'a str) -> &'a str;

In Rust, all references have an attached lifetime; this is part of the type. The above bar function says more than just “this function takes a reference to a string and returns another one”. It says “this function takes a string reference, and returns another which is valid for as long as the one it’s given. This is an important part of Rust’s ownership system.

However, it’s annoying and a pain to specify these lifetimes every time, so Rust has “lifetime elision” (i.e. “not explicitly writing them out”). All that means is that for a few very common cases, you can leave the lifetime annotations out and Rust will implicitly add them for you. This is purely a convenience for programmers so that they don’t have to write so many lifetimes in “obvious” cases.

The rules are listed in the book, but for completeness they are:

  1. Every lifetime in the function parameters which isn’t otherwise specified is different. For example:
fn f(x: &T, y: &U)

means:

fn f<'a, 'b>(x: &'a T, y: &'b U)

i.e. there’s no automatic link between those lifetimes.

  1. If there’s only one input lifetime, it’s used for every output lifetime. For example:
struct U<'a> {}  // struct with a lifetime parameter

fn f(x: &T) -> &U

becomes:

fn f<'a>(x: &'a T) -> &'a U<'a>
  1. Otherwise, if there are multiple input lifetimes but one of them is &self or &mut self (i.e. it’s a method), then all the elided output lifetimes get the same as self. This covers the common case that a method returns a reference to one of its fields. For example:
impl S {
    fn get_my_item(&self, key: &str) -> &str {}
}

becomes:

fn get_my_item<'a,'b>(&'a self, key: &'b str) -> &'a str  // use the self lifetime

The documentation has some more examples.

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. What are non-lexical lifetimes?
  3. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  4. How can I create my own data structure with an iterator that returns mutable references?
  5. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  6. Why does linking lifetimes matter only with mutable references?
  7. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  8. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  9. When is it useful to define multiple lifetimes in a struct?
  10. Lifetime troubles sharing references between threads
  11. Moved variable still borrowing after calling `drop`?
  12. “borrowed value does not live long enough” when using the builder pattern
  13. How can this instance seemingly outlive its own parameter lifetime?
  14. How do I specify lifetime parameters in an associated type?
  15. How to operate on 2 mutable slices of a Rust array?
  16. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  17. Why does my variable not live long enough?
  18. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  19. Sharing a struct with trait objects as properties across threads
  20. Why can’t I return an &str value generated from a String?
  21. Type mismatches resolving a closure that takes arguments by reference
  22. How to fix lifetime error when function returns a serde Deserialize type?
  23. Why does Rust disallow mutable aliasing?
  24. Extend lifetime of variable
  25. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?
  26. Can I do type introspection with trait objects and then downcast it?
  27. How can I perform parallel asynchronous HTTP GET requests with reqwest?
  28. error [E0716]: temporary value dropped while borrowed (rust)
  29. Can I get a trait object of a multi-trait instance without using a generic type?
  30. How to iterate over and filter an array?

Leave a Comment