Lifetimes, ou le temps inscrit dans le type Lifetimes, or time written into the type

Une référence ne doit jamais survivre à sa donnée.A reference must never outlive its data.

Le Vol 1 s'est clos sur une question laissée ouverte : une slice pointe à l'intérieur d'une donnée qu'elle ne possède pas — que se passe-t-il si le propriétaire la libère pendant que la vue regarde encore ? Dans un langage à pointeurs nus, c'est le use-after-free : un pointeur qui désigne de la mémoire déjà rendue. La cause numéro un de failles mémoire. Rust en fait une erreur de compilation. Voici comment il s'y prend.Vol 1 closed on a question left open: a slice points inside data it doesn't own — what happens if the owner frees it while the view is still looking? In a raw-pointer language, that's use-after-free: a pointer designating already-returned memory. The number-one cause of memory vulnerabilities. Rust turns it into a compile error. Here's how.

let r;                       // une référence...
{
    let x = 5;               // x naît ici
    r = &x;                  // r emprunte x
}                            // x meurt ICI — sa mémoire est libérée

println!("{r}");             // ✕ r désignerait de la mémoire morte
// error[E0597]: `x` does not live long enough

Le compilateur refuse — non par sévérité, mais par ignorance.The compiler refuses — not from strictness, but from ignorance.

Une fonction qui renvoie une référence pose une question que sa signature, seule, ne sait pas trancher : la référence rendue pointe-t-elle dans x, ou dans y ? De cette réponse dépend la durée de vie du résultat. Tant qu'elle n'est pas dans la signature, le compilateur ne peut prouver que l'appelant n'obtiendra pas une référence pendante. Il ne devine pas — il exige qu'on relie les durées.A function returning a reference poses a question its signature alone can't settle: does the returned reference point into x, or into y? The result's lifetime depends on that answer. Until it's in the signature, the compiler can't prove the caller won't get a dangling reference. It doesn't guess — it demands you relate the durations.

fn plus_long(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}
// error[E0106]: missing lifetime specifier
//   --> le type de retour contient une valeur empruntée,
//      mais la signature ne dit pas DE LAQUELLE des deux entrées

Le code semble évident — il l'est, pour un humain. Mais le compilateur raisonne par signatures, pas par corps de fonction : il regarde (&str, &str) -> &str et voit une sortie empruntée sans savoir à quelle entrée rattacher sa durée. Sans ce lien, impossible de garantir à l'appelant que le résultat survivra assez — ni trop.The code looks obvious — it is, to a human. But the compiler reasons by signatures, not by function bodies: it sees (&str, &str) -> &str and finds a borrowed output with no idea which input to tie its duration to. Without that link, it can't guarantee the caller the result will live long enough — nor not too long.

Le résultat vit aussi longtemps que la plus courte des entrées.The result lives as long as the shortest input.

Une fois les trois références reliées par 'a, le compilateur fixe 'a, à chaque appel, à l'intersection des durées : la fenêtre où toutes les entrées marquées 'a sont simultanément vivantes. Le résultat ne peut être utilisé que dans cette fenêtre. C'est pour ça que plus_long n'a pas besoin de savoir laquelle des deux il renverra — il suffit que le résultat ne dépasse aucune des deux.Once the three references are linked by 'a, the compiler sets 'a, at each call, to the intersection of durations: the window where all inputs marked 'a are simultaneously alive. The result may only be used within that window. That's why plus_long needn't know which of the two it returns — it's enough that the result outruns neither.

let r;
let longue = String::from("une phrase longue");
{
    let courte = String::from("brève");
    r = plus_long(&longue, &courte);   // 'a = la PLUS COURTE des deux
    println!("{r}");                   // ok ICI : courte est vivante
}                                      // courte meurt — donc 'a finit ici
// println!("{r}");                    // ✕ r ne peut survivre à courte

Distinguer les durées : plusieurs paramètres de lifetimeDistinguishing durations: several lifetime parameters

Tout marquer 'a est parfois trop grossier. Si le résultat ne dépend que de x, on l'écrit : fn premier<'a, 'b>(x: &'a str, y: &'b str) -> &'a str. Là, y peut mourir bien avant sans contraindre le résultat — sa durée 'b est indépendante. On relie ce qui est lié, on sépare ce qui ne l'est pas. La signature devient une carte exacte des dépendances de durée.Marking everything 'a is sometimes too coarse. If the result depends only on x, write it so: fn first<'a, 'b>(x: &'a str, y: &'b str) -> &'a str. There, y may die well earlier without constraining the result — its duration 'b is independent. Link what's linked, separate what isn't. The signature becomes an exact map of duration dependencies.

Croire qu'une annotation peut créer de la durée de vie.Believing an annotation can create lifetime.

Le piège jumeau de tout ce volume : devant une erreur de lifetime, ajouter des 'a un peu partout en espérant faire taire le compilateur. Mais une annotation ne fabrique pas de la vie — elle décrit celle qui existe. Si tu renvoies une référence vers une donnée locale, aucune notation au monde ne la fera survivre à la fonction. Le message n'est pas « il manque un 'a » : c'est « cette donnée meurt trop tôt ».The twin trap of this whole volume: facing a lifetime error, sprinkling 'a everywhere hoping to silence the compiler. But an annotation fabricates no life — it describes what exists. If you return a reference to local data, no notation on earth makes it outlive the function. The message isn't 'a 'a is missing': it's 'this data dies too soon'.

fn etiquette<'a>() -> &'a str {
    let s = String::from("brouillon");
    &s                       // ✕ on renvoie une vue sur s...
}                            // ...mais s meurt ici. 'a ne peut rien y faire.
// error[E0515]: cannot return reference to local variable `s`

Le 'a dans la signature promet « je renvoie une référence valide pour une durée choisie par l'appelant ». Mais le corps emprunte s, une variable locale qui meurt à l'accolade fermante. La promesse est intenable : il n'existe aucune durée où la vue serait encore valide hors de la fonction. Le compilateur ne réclame pas une annotation de plus — il refuse une contradiction.The 'a in the signature promises 'I return a reference valid for a duration the caller picks'. But the body borrows s, a local variable that dies at the closing brace. The promise can't be kept: there's no duration in which the view is still valid outside the function. The compiler isn't asking for one more annotation — it's refusing a contradiction.

fn etiquette() -> String {
    let s = String::from("brouillon");
    s                        // on rend la POSSESSION, pas une vue
}                            // s sort de la fonction vivant, par move

La donnée naît dans la fonction : elle ne peut en sortir que par move, pas par emprunt. On renvoie un String possédé — c'est exactement la convention du Vol 1 №3 : emprunte ce que tu lis, possède ce que tu produis. Pas de lifetime ici, parce qu'il n'y a aucune référence à relier : on transfère une valeur entière.The data is born inside the function: it can leave only by move, not by borrow. You return an owned String — exactly the Vol 1 №3 convention: borrow what you read, own what you produce. No lifetime here, because there's no reference to link: you transfer a whole value.