Move semantics, ou la valeur qu'on déplace Move semantics, or the value you move

Deux lettres, une seule donnée. Trace le propriétaire.Two names, one value. Trace the owner.

Trois lignes que tout le monde écrit le premier jour. Elles ne compilent pas — et le refus du compilateur, ici, n'est pas un caprice de syntaxe : c'est le modèle entier de Rust qui tient dans un seul let. La possession se transfère, elle ne se duplique pas.Three lines everyone writes on day one. They don't compile — and the compiler's refusal here is no syntactic quibble: it's all of Rust's model fitting inside a single let. Ownership transfers, it does not duplicate.

let a = String::from("hello");
let b = a;            // on croit copier a dans b
println!("{a}");      // ← et ici, le compilateur refuse

En JS, b = a partage. En Rust, il déménage.In JS, b = a shares. In Rust, it moves out.

Quand on vient d'un langage à GC, « assigner » veut dire « faire pointer une deuxième variable sur la même donnée ». Deux noms, un objet, mutation partagée — et un bug d'aliasing qui compile sans broncher. Rust prend le contre-pied : assigner, c'est céder.Coming from a GC language, 'assigning' means 'make a second variable point at the same data'. Two names, one object, shared mutation — and an aliasing bug that compiles without a peep. Rust takes the opposite stance: to assign is to hand over.

let a = { tag: "hello" };
let b = a;             // b et a pointent le MÊME objet
b.tag = "bye";
console.log(a.tag);    // "bye" — a a muté dans ton dos

Rien ne plante. a et b désignent le même objet : muter l'un mute l'autre. Le jour où ce code casse en production, le bug est à mille lignes de l'assignation. Le compilateur n'avait rien à dire — il n'y avait, pour lui, aucune erreur.Nothing crashes. a and b name the same object: mutating one mutates the other. The day this breaks in production, the bug is a thousand lines from the assignment. The compiler had nothing to say — to it, there was no error.

Un propriétaire, un drop. Voilà le théorème.One owner, one drop. That's the theorem.

Passer une valeur à une fonction, c'est lui en céder la possession — exactement comme l'affectation. Pourquoi cette intransigeance ? Parce qu'une valeur a, à tout instant, un seul propriétaire ; et quand ce propriétaire sort de portée, sa donnée est libérée une fois, exactement. Pas de double libération possible : elle est inexprimable.Passing a value to a function hands over its ownership — exactly like assignment. Why the rigidity? Because a value has, at any instant, a single owner; and when that owner goes out of scope, its data is freed once, exactly. No double-free is possible: it is inexpressible.

fn consume(s: String) {        // consume PREND possession
    println!("{s}");
}                              // ici s est droppé : la mémoire est libérée

let name = String::from("Ada");
consume(name);                 // possession transférée à la fonction
println!("{name}");            // error[E0382] : name a été moved

Pour réutiliser name après l'appel, deux issues honnêtes : retourner la valeur (let name = consume(name);) pour récupérer la possession, ou — au prochain numéro — l'emprunter au lieu de la céder (consume(&name)). Cloner « pour que ça passe » est le réflexe à éviter ; on y vient au chapitre 4.To reuse name after the call, two honest exits: return the value (let name = consume(name);) to get ownership back, or — next issue — borrow it instead of giving it away (consume(&name)). Cloning 'to make it pass' is the reflex to avoid; we get to it in chapter 4.

L'exception qui confirme : les types CopyThe exception that confirms: Copy types

let x = 5;        // i32 : type Copy (vit sur la pile)
let y = x;        // x est COPIÉ, pas déplacé
println!("{x}");  // 5 — x est toujours là, intact

let a = String::from("hello");
let b = a.clone();   // duplication explicite du tas
println!("{a}");     // hello — a possède toujours sa copie

.clone() partout, ou comment racheter le GC qu'on a fui..clone() everywhere, or how to buy back the GC you fled.

Le réflexe du débutant venant d'un langage à GC : dès que le compilateur crie « moved value », coller un .clone() jusqu'à ce que ça passe. Ça marche. Et ça réintroduit, à la main et au prix fort, exactement les copies et allocations que Rust voulait te faire voir. Le compilateur ne criait pas pour t'embêter — il te demandait de décider.The beginner's reflex coming from a GC language: the moment the compiler shouts 'moved value', slap on a .clone() until it passes. It works. And it reintroduces, by hand and at full price, exactly the copies and allocations Rust wanted you to see. The compiler wasn't shouting to annoy you — it was asking you to decide.

fn total(items: Vec<Item>) -> u64 { /* ... */ }

let cart = vec![/* 10 000 items */];
let t = total(cart.clone());   // clone pour « que ça passe »
render(cart);                  // on réutilise cart après

Ce .clone() duplique dix mille items sur le tas, à chaque appel, uniquement parce qu'on n'a pas voulu réfléchir à qui possède le panier. La valeur n'avait jamais besoin d'être copiée : total veut juste la lire.This .clone() duplicates ten thousand items on the heap, on every call, solely because we didn't want to think about who owns the cart. The value never needed copying: total just wants to read it.

fn total(items: &[Item]) -> u64 { /* ... */ }   // emprunte, ne possède pas

let cart = vec![/* 10 000 items */];
let t = total(&cart);          // on prête cart, on ne le cède pas
render(&cart);                 // cart est toujours à nous, zéro copie

Une référence (&cart) : total regarde le panier sans en prendre possession, donc rien à céder, rien à cloner, rien à reconstruire. C'est le sujet du prochain numéro (Vol 1 · №02, l'emprunt) — mais le réflexe naît ici : avant de cloner, demande-toi si tu voulais seulement lire.A reference (&cart): total looks at the cart without taking ownership, so nothing to give up, nothing to clone, nothing to rebuild. That's the subject of the next issue (Vol 1 · №02, borrowing) — but the reflex is born here: before cloning, ask whether you only meant to read.