Elision

Some lifetime patterns are overwelmingly common and so the borrow checker
will implicitly add them to save typing and to improve readability.
This process of implicit addition is called elision. Elision exists in Rust
solely because these patterns are common.

The following code shows a few examples of elision. For a more comprehensive
description of elision, see lifetime elision in the book.

  1. // `elided_input` and `annotated_input` essentially have identical signatures
  2. // because the lifetime of `elided_input` is elided by the compiler:
  3. fn elided_input(x: &i32) {
  4.     println!("`elided_input`: {}", x);
  5. }
  7. fn annotated_input<'a>(x: &'a i32) {
  8.     println!("`annotated_input`: {}", x);
  9. }
  11. // Similarly, `elided_pass` and `annotated_pass` have identical signatures
  12. // because the lifetime is added implicitly to `elided_pass`:
  13. fn elided_pass(x: &i32) -> &i32 { x }
  15. fn annotated_pass<'a>(x: &'a i32) -> &'a i32 { x }
  17. fn main() {
  18.     let x = 3;
  20.     elided_input(&x);
  21.     annotated_input(&x);
  23.     println!("`elided_pass`: {}", elided_pass(&x));
  24.     println!("`annotated_pass`: {}", annotated_pass(&x));
  25. }

See also:

elision