Elision rules

Learn the lifetime elision rules.

Elision rules

The reason you don't need to write lifetimes in most functions is the compiler's three elision rules:

Each reference parameter gets its own lifetime.
If there is exactly one reference parameter, its lifetime is given to all returned references.
If one of the parameters is &self or &mut self, the lifetime of self is given to the return.

fn kisalt(s: &str) -> &str           // rule 2: fn kisalt<'a>(s: &'a str) -> &'a str
fn ad(&self, ek: &str) -> &str       // rule 3: return tied to self

The rules at work

No lifetimes are written in the two functions below, yet both are valid:

fn kisalt(s: &str) -> &str {
    s.get(..3).unwrap_or(s)
}

struct Kisi { ad: String }

impl Kisi {
    fn ad(&self) -> &str {
        &self.ad
    }
}

get(..3) is a safe slice: if the text is shorter than 3 bytes or byte 3 falls in the middle of a character, it returns None.

Exercise Signatures without lifetimes

Define the kisalt function above and the ad method of the Kisi type without writing lifetimes. Print the results of kisalt("Programlama") and Kisi { ad: "Ece".to_string() }.ad() separated by a space.

Show example solution

fn kisalt(s: &str) -> &str {
    s.get(..3).unwrap_or(s)
}

struct Kisi {
    ad: String,
}

impl Kisi {
    fn ad(&self) -> &str {
        &self.ad
    }
}

fn main() {
    let k = Kisi { ad: "Ece".to_string() };
    println!("{} {}", kisalt("Programlama"), k.ad());
}

Test yourself

Why does <code>fn f(a: &str, b: &str) -> &str</code> need a lifetime?
- str always needs a lifetime
- It doesn't
- There are two reference parameters and no self; rules 2 and 3 can't apply
- The return type is wrong
Show answer

There are two reference parameters and no self; rules 2 and 3 can't apply — When the rules can't determine the return lifetime, the compiler asks for an annotation (E0106).

Elided lifetime

fn kisalt(s: &str) -> ____ {
    s.get(..3).unwrap_or(s)
}

Show answer

fn kisalt(s: &str) -> &str {
    s.get(..3).unwrap_or(s)
}

Signature and the rule applied

fn f(x: &str) -> &str

Rule 2
fn f(&self, y: &str) -> &str

Rule 3
fn f(x: &str, y: &str)

Rule 1 (no return)
fn f(x: &str, y: &str) -> &str

Annotation needed

Next lesson: Summary - Lifetimes

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies