Concept of Lifetime

[turbid osprey]

What's the purpose of Lifetime I just need a example rather than this

let a = String::from("value");
let result;
{
  let b = String::from ("Value 123");
  result = get_max_val(&a,&b);
}
println!("{},&result);

fn get_max_val<'a>(a:&'a str,b:&'a str) -> &'a str{
 ..... Giving the max len string
}

[long hazel]

well the basic purpose is that you're telling the compiler how long the reference is valid for

[turbid osprey]

Means a type of reminder .??

[inland light]

you are saying that the lifetime return type of the function is the same as both of the inputs

[turbid osprey]

Ok

So what if they both have diffrence life time aka <'a,'b>

[inland light]

this doesnt work because b is dropped before the print

[inland light]

which one are you returning

[turbid osprey]

B

Inside the scope one....

[long hazel]

fn main() {
    let s = "hello".to_string();
    let ref_to_s = &s;
    drop(s);
    println!("{}", *ref_to_s); // ERROR
}

In this example you can't use ref_to_s because it isn't valid anymore. The lifetime of s has expired

in this example the compiler was able to figure out all the lifetimes itself

[inland light]

then the return type lifetime is the same as 'b

[long hazel]

but sometimes you need to specify it manually

[turbid osprey]

Ohhh

[inland light]

you mean this? fn get_max_val<'a>(a: &'a str, b: &'b str) -> &'b str

[long hazel]

(note: in C there would be no error and it would probably just segfault or something)

[turbid osprey]

Any way to fix it.??

[turbid osprey]

I am from java background 🙂

[inland light]

use the ref before you drop it

or just dont drop it

[long hazel]

well my code is nonsensical, it drops the string and then tries to print it

[turbid osprey]

Dayem it's brutal making my mind coocked

[inland light]

also you cant drop s because it is borrowed

[inland light]

drop is just fn drop<T>(_x: T) {}

[turbid osprey]

Yeah I see

[turbid osprey]

Got it I just looked the docs

[long hazel]

so in this example you're telling the compiler: "we return a reference to a string, and this reference is valid only when a and b are valid references"

[turbid osprey]

Hmmm

Got it

[long hazel]

@turbid osprey here's an example in C that shows how you need to handle lifetimes manually

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main() {
    char* s = malloc(12); 
    strcpy(s, "hello there");
    // s is a reference to a string that lives in the heap

    printf("%s\n", s); // this is ok
    free(s); // equivalent to `drop` in Rust
    printf("%s\n", s); // UB

    return 0;
}

this is an obvious example but if you're returning s from a function it might be tough to keep track of whether or not it has been freed