'static & le combat contre le borrow checker 'static & the fight against the borrow checker

La spirale : annoter plus fort, jusqu'à 'static, jusqu'à abandonner.The spiral: annotate harder, up to 'static, until you give up.

Le numéro précédent a donné les trois règles d'élision et le moyen d'écrire une annotation juste. Mais il existe un point au-delà duquel annoter ne corrige plus rien — où chaque 'a ajouté déplace l'erreur sans la résoudre. Le débutant y répond en annotant plus fort, jusqu'au coup de désespoir : coller 'static partout. C'est presque toujours le mauvais geste, et il dit quelque chose de précis — le problème n'est pas dans les durées, il est dans la possession.The previous issue gave the three elision rules and how to write a correct annotation. But there's a point beyond which annotating fixes nothing — where each added 'a moves the error without resolving it. The beginner responds by annotating harder, up to the act of despair: slapping 'static everywhere. It's almost always the wrong move, and it says something precise — the problem isn't in the durations, it's in ownership.

fn dernier<'a>(v: &'a Vec<&'a str>) -> &'a str { /* ... */ }
// erreur ailleurs → on ajoute une durée
fn dernier<'a, 'b>(v: &'a Vec<&'b str>) -> &'b str { /* ... */ }
// erreur encore → on lie les deux
fn dernier<'a, 'b: 'a>(v: &'a Vec<&'b str>) -> &'b str { /* ... */ }
// erreur toujours → le réflexe fatal :
fn dernier(v: &Vec<&'static str>) -> &'static str { /* ... */ }
//                       ^^^^^^^ « vit pour toujours » — la fausse sortie

Une référence dans une struct contamine tout ce qui la touche.A reference in a struct infects everything that touches it.

La spirale du numéro a une source presque unique : une struct qui stocke une référence. Dès qu'un champ est emprunté, la struct porte une durée — et cette durée se propage à chaque impl, chaque fonction, chaque struct qui la contient, comme une teinture qui remonte le tissu. C'est là que naissent les 'a en cascade. La question n'est pas « comment annoter cette struct », mais « cette struct doit-elle vraiment emprunter ? ».The issue's spiral has an almost single source: a struct storing a reference. The moment a field is borrowed, the struct carries a duration — and that duration propagates to every impl, every function, every struct containing it, like dye creeping up cloth. That's where cascading 'a are born. The question isn't 'how do I annotate this struct', but 'should this struct borrow at all?'.

struct Config<'a> {           // la struct EMPRUNTE son nom
    nom: &'a str,
}

// la durée 'a contamine tout ce qui touche Config :
impl<'a> Config<'a> {
    fn nom(&self) -> &str { self.nom }
}
fn charger<'a>(src: &'a str) -> Config<'a> { /* ... */ }
struct App<'a> { config: Config<'a> }      // ...et ça remonte
// chaque appelant doit prouver que `src` survit à la Config. Partout.

Chaque <'a> de plus n'est pas une faute — c'est la conséquence mécanique du premier choix : le champ nom: &'a str. La struct ne possède pas son nom, donc elle doit prouver, à vie, que la donnée empruntée lui survit. Cette preuve, l'appelant doit la fournir partout — et la moindre construction qui ne peut pas la garantir échoue. C'est exactement le terrain où l'on dégaine 'static par dépit.Each extra <'a> isn't a mistake — it's the mechanical consequence of the first choice: the field nom: &'a str. The struct doesn't own its name, so it must prove, for life, that the borrowed data outlives it. That proof, the caller must supply everywhere — and any construction that can't guarantee it fails. This is exactly the ground where you reach for 'static out of spite.

Trois manières de tenir une donnée — et une seule par défaut.Three ways to hold data — and only one default.

Devant un champ, une fonction, un type, le choix n'est pas « combien de 'a faut-il ». C'est, d'abord : faut-il posséder, emprunter, ou exiger l'éternel ? Les trois sont légitimes — mais pas interchangeables, et leur ordre de préférence est clair. On possède par défaut. On emprunte quand la vue est brève et locale. On exige 'static seulement quand la donnée est réellement éternelle — jamais pour faire taire une erreur.Facing a field, a function, a type, the question isn't 'how many 'a do I need'. It's, first: should I own, borrow, or demand the eternal? All three are legitimate — but not interchangeable, and their order of preference is clear. Own by default. Borrow when the view is brief and local. Demand 'static only when the data is genuinely eternal — never to silence an error.

L'ordre est aussi celui de préférence : possède, sauf raison de ne pas le faire.The order is also the preference: own, unless there's a reason not to.

Le 'static légitime, et le 'static-cache-misèreLegitimate 'static, and band-aid 'static

Il y a un usage parfaitement sain de 'static : une donnée qui est réellement éternelle. Un littéral &str est gravé dans le binaire — sa durée est 'static par nature, et l'écrire est honnête.There's a perfectly healthy use of 'static: data that genuinely is eternal. A &str literal is baked into the binary — its duration is 'static by nature, and writing it is honest.

const VERSION: &'static str = "1.0.0";   // honnête : vraiment éternel
fn defaut() -> &'static str { "anonyme" }   // un littéral : 'static naturel

// vs. le cache-misère, à fuir :
fn nom(c: &Config) -> &'static str {
    Box::leak(c.nom.clone().into_boxed_str())   // ✕ on FUIT de la mémoire
}                                                // pour fabriquer du 'static

Le dernier cas est le symptôme ultime de la spirale : ne pouvant prouver la durée, on fabrique de l'éternel en fuyant volontairement de la mémoire (Box::leak). Le compilateur est satisfait, le programme « marche » — et fuit un peu plus à chaque appel. On a transformé un problème de design en fuite mémoire silencieuse. Le bon geste était, trois étapes plus tôt : posséder.The last case is the spiral's ultimate symptom: unable to prove the duration, you manufacture the eternal by deliberately leaking memory (Box::leak). The compiler is happy, the program 'works' — and leaks a little more on every call. You've turned a design problem into a silent memory leak. The right move was, three steps earlier: own.

Le mur final : la structure dont les nœuds se pointent mutuellement.The final wall: the structure whose nodes point at each other.

Il existe une classe de problèmes où aucune annotation, même 'static, ne peut aboutir : les structures à références croisées — un arbre dont les nœuds pointent vers leur parent et leurs enfants, un graphe avec des cycles, une liste doublement chaînée. Le débutant y voit la preuve que « Rust est trop rigide » et dégaine Rc<RefCell>, unsafe, ou des pointeurs bruts. Le bon réflexe est tout autre : cesser de stocker des références, et stocker des indices.There's a class of problems where no annotation, not even 'static, can succeed: cross-referencing structures — a tree whose nodes point to their parent and their children, a graph with cycles, a doubly linked list. The beginner takes this as proof that 'Rust is too rigid' and reaches for Rc<RefCell>, unsafe, or raw pointers. The right reflex is wholly different: stop storing references, and store indices.

// Un nœud qui connaît son parent ET ses enfants : des références dans les deux sens
struct Noeud<'a> {
    valeur: i32,
    parent: Option<&'a Noeud<'a>>,   // vers le haut…
    enfants: Vec<&'a Noeud<'a>>,     // … et vers le bas
}
let mut racine = Noeud { valeur: 0, parent: None, enfants: vec![] };
let fils = Noeud { valeur: 1, parent: Some(&racine), enfants: vec![] };
racine.enfants.push(&fils);   // ✕ error[E0502]: cannot borrow `racine.enfants` as mutable
                              //   because it is also borrowed as immutable
// Le parent doit exister AVANT l'enfant (pour être pointé),
// et être modifié APRÈS (pour pointer l'enfant) : aucun ordre ne marche.

Une référence promet que sa donnée lui survit. Dans un cycle, c'est impossible à prouver : A dépend de B qui dépend de A. Aucune durée ne satisfait les deux contraintes à la fois, et le compilateur a raison de refuser — la structure, telle qu'écrite, ne peut être libérée sans ambiguïté. Empiler les 'a ou tenter 'static ne fait que reculer le mur d'un pas.A reference promises its data outlives it. In a cycle, that's impossible to prove: A depends on B which depends on A. No duration satisfies both constraints at once, and the compiler is right to refuse — the structure, as written, can't be freed unambiguously. Stacking 'a or trying 'static only pushes the wall back one step.

// On ne stocke pas des références, mais des INDICES dans une arène
struct Arbre {
    noeuds: Vec<Noeud>,              // tout est possédé, à plat
}
struct Noeud {
    valeur: i32,
    parent: Option<usize>,           // un index, pas une référence
    enfants: Vec<usize>,             // idem vers le bas
}
// Plus aucune durée : l'arène possède tout, les liens sont des entiers.
// On navigue par arbre.noeuds[i] — vérifié, sûr, sans un seul 'a.

Un Vec possède tous les nœuds, à plat ; les liens deviennent des usize — de simples entiers, sans durée. Le cycle disparaît parce qu'il n'y a plus qu'un seul propriétaire, l'arène, et que les indices ne prétendent rien sur la durée de vie. C'est le pattern qu'utilisent les vrais arbres et graphes en Rust — pas par contournement, mais parce que c'est le modèle de possession honnête pour une donnée cyclique.A Vec owns all the nodes, flat; the links become usize — plain integers, no duration. The cycle vanishes because there's now a single owner, the arena, and indices claim nothing about lifetime. This is the pattern real trees and graphs use in Rust — not as a workaround, but because it's the honest ownership model for cyclic data.