Lifetime

Lifetime in Function

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { todo!() }

The function signature tells Rust that for some lifetime ‘a, the function takes two parameters, both of which are string slices that live at least as long as lifetime ‘a.
The function signature also tells Rust that the string slice returned from the function will live at least as long as lifetime ‘a.
In practice, it means that the lifetime of the reference returned by the longest function is the same as the smaller of the lifetimes of the values referred to by the function arguments.

struct StructWithLifetime<'a> {
    str_slice_test: &'a str,
    int_test: &'a i32,
}

Lifetimes on function or method parameters are called input lifetimes, and lifetimes on return values are called output lifetimes.

Three rules to figure out the lifetimes, first applies to input lifetime, second and third is applied to output lifetime

Compiler assigns a lifetime parameter to each parameter that’s a reference.
- One Parameter
```
fn foo<'a>(x: &'a i32)
```
- Two Parameter
```
fn foo<'a, 'b>(x: &'a i32, y: &'b i32)
```
If there is exactly one input lifetime parameter, that lifetime is assigned to all output lifetime parameters:

fn foo<'a>(x: &'a i32) -> &'a i32.

If there are multiple input lifetime parameters, but one of them is &self or &mut self because this is a method, the lifetime of self is assigned to all output lifetime parameters.

impl<'a> StructWithLifetime<'a> {}