Borrowing, ou la règle aliasing XOR mutation Borrowing, or the aliasing XOR mutation rule

Prêter une donnée. La regarder sans la posséder.Lend a value. Look at it without owning it.

Le numéro précédent finissait sur une promesse : avant de cloner, demande-toi si tu voulais seulement lire. Voici la réponse. Un emprunt — une référence, le & — donne accès à une donnée sans en transférer la possession. La fonction lit, le propriétaire d'origine garde tout. Pas de move, pas de clone, pas d'allocation.The previous issue ended on a promise: before cloning, ask whether you only meant to read. Here's the answer. A borrow — a reference, the & — gives access to a value without transferring its ownership. The function reads, the original owner keeps everything. No move, no clone, no allocation.

fn longueur(s: &String) -> usize {   // & : on EMPRUNTE, on ne possède pas
    s.len()
}                                     // s sort de portée, mais ne droppe rien

let nom = String::from("Ada");
let n = longueur(&nom);               // on prête nom le temps de l'appel
println!("{nom} fait {n} lettres");   // nom est toujours à nous

Lire et muter en même temps. Le bug que Python te laisse écrire.Read and mutate at once. The bug Python lets you write.

Itérer sur une collection tout en la modifiant : un classique. En Python ou en JS, le code tourne — et l'itérateur saute un élément, ou explose, selon l'humeur. C'est l'invalidation d'itérateur, un bug d'aliasing : deux accès à la même donnée, dont l'un mute. Rust regarde exactement ces deux accès et refuse de compiler.Iterating over a collection while modifying it: a classic. In Python or JS, the code runs — and the iterator skips an element, or blows up, depending on its mood. That's iterator invalidation, an aliasing bug: two accesses to the same data, one of them mutating. Rust looks at exactly those two accesses and refuses to compile.

items = [1, 2, 2, 3]
for x in items:          # on ITÈRE (on lit)
    if x == 2:
        items.remove(x)  # ... et on MUTE pendant l'itération
# pas d'erreur — mais l'itérateur saute le second 2 : [1, 2, 3], faux

Aucune erreur levée. L'itérateur avance d'un cran pendant que la liste rétrécit sous lui : il saute l'élément suivant. Le résultat est silencieusement faux. Le bug ne vit pas dans remove ni dans for pris séparément — il naît de leur simultanéité.No error raised. The iterator steps forward while the list shrinks beneath it: it skips the next element. The result is silently wrong. The bug lives neither in remove nor in for taken alone — it's born of their simultaneity.

Plusieurs lecteurs, ou un seul écrivain. Jamais les deux.Many readers, or one writer. Never both.

Voici la règle d'or, et elle tient en une ligne : à tout instant, une donnée peut avoir soit autant de références partagées qu'on veut, soit exactement une référence exclusive — jamais les deux à la fois. Ce n'est pas une contrainte arbitraire du langage. C'est, exactement, la condition qui rend une course de données impossible à écrire.Here's the golden rule, and it fits on one line: at any instant, a value may have either as many shared references as you like, or exactly one exclusive reference — never both at once. This is no arbitrary language constraint. It is, exactly, the condition that makes a data race impossible to write.

Lecture seule = partageable. Écriture = exclusive. Le XOR est dans le « jamais les deux ».Read-only = shareable. Write = exclusive. The XOR is in the 'never both'.

L'emprunt ne dure que jusqu'à son dernier usage (NLL)A borrow lasts only until its last use (NLL)

La règle effraie moins qu'il n'y paraît, parce qu'un emprunt ne vit pas jusqu'à la fin du bloc : il meurt à sa dernière utilisation. C'est le non-lexical lifetime. Une fois le lecteur fini de lire, l'écrivain peut entrer.The rule is less frightening than it looks, because a borrow doesn't live to the end of the block: it dies at its last use. That's the non-lexical lifetime. Once the reader is done reading, the writer may step in.

let mut s = String::from("hello");

let r = &s;            // emprunt partagé commence
println!("{r}");       // ... et finit ICI, à son dernier usage

s.push_str(" world");  // &mut s : autorisé, le & est déjà mort
println!("{s}");       // hello world

À vous — le compilateur répond pour de bonYour turn — the compiler answers for real

Trois programmes refusés, trois lignes à déplacer. Rien à supprimer, rien à cloner — le sous-ensemble n'a même pas de .clone(), ce n'est pas une limite mais l'énoncé. Ce qui répond n'est pas une correction enregistrée : c'est un borrow checker qui recalcule les régions à chaque frappe, et dont les verdicts sont confrontés au vrai rustc à chaque build du site. La colonne de droite dessine chaque emprunt du & jusqu'à son dernier usage : deux barres qui se chevauchent sur la même valeur, c'est l'erreur, avant même de la lire.Three rejected programs, three lines to move. Nothing to delete, nothing to clone — the subset doesn't even have .clone(), which isn't a limitation but the exercise. What answers isn't a recorded correction: it's a borrow checker recomputing regions on every keystroke, whose verdicts are checked against the real rustc on every build of this site. The right-hand column draws each borrow from its & to its last use: two bars overlapping on the same value is the error, before you've even read it.

Dégainer Rc<RefCell> pour faire taire le borrow checker.Reaching for Rc<RefCell> to silence the borrow checker.

Le borrow checker refuse ton code. Deux échappatoires tentantes : cloner partout (on retombe dans le piège du numéro précédent), ou emballer la donnée dans Rc<RefCell> pour récupérer le partage mutable d'un langage à GC. Les deux compilent. Les deux réintroduisent à l'exécution exactement ce que la règle avait éliminé à la compilation — le clone son coût, le RefCell son panic.The borrow checker refuses your code. Two tempting escape hatches: clone everywhere (back into the previous issue's trap), or wrap the data in Rc<RefCell> to win back a GC language's shared mutation. Both compile. Both reintroduce at runtime exactly what the rule eliminated at compile time — the clone its cost, the RefCell its panic.

// « Le borrow checker crie, je dégaine Rc<RefCell> »
let shared = Rc::new(RefCell::new(items));
let a = Rc::clone(&shared);
let b = Rc::clone(&shared);
a.borrow_mut().push(1);
b.borrow_mut().push(2);   // compile... et panique à l'exécution si les
                          // deux borrow_mut se chevauchent : « RefCell already borrowed »

RefCell ne supprime pas la règle « aliasing XOR mutation » : il la déplace du compilateur vers l'exécution. Deux borrow_mut() qui se chevauchent ne sont plus une erreur de compilation mais un panic à l'exécution (« RefCell already borrowed ») — le bug que le Vol 1 t'avait épargné, ressuscité, et cette fois invisible jusqu'au crash. On y reviendra au Vol 6 ; ici, c'est le réflexe qu'on dénonce, pas l'outil.RefCell doesn't remove the 'aliasing XOR mutation' rule: it moves it from the compiler to runtime. Two overlapping borrow_mut() calls are no longer a compile error but a runtime panic ('RefCell already borrowed') — the bug Vol 1 spared you, resurrected, and this time invisible until the crash. We'll return to it in Vol 6; here, it's the reflex we indict, not the tool.

// On garde l'emprunt court : le conflit disparaît de lui-même
let len = {
    let view = &items;        // emprunt partagé
    view.len()
};                            // l'emprunt meurt ici
items.push(len);              // &mut libre : plus aucun chevauchement

Neuf fois sur dix, le conflit vient d'un emprunt qui traîne au-delà de son utilité. Un bloc { }, une variable intermédiaire, et le partagé meurt avant que l'exclusif n'arrive. Pas de clone, pas de RefCell : juste un emprunt qui ne dure que ce qu'il doit.Nine times out of ten, the conflict comes from a borrow that lingers past its usefulness. A { } block, an intermediate variable, and the shared borrow dies before the exclusive one arrives. No clone, no RefCell: just a borrow that lasts only as long as it must.