clone, Cow & l'allocation cachée clone, Cow & the hidden allocation

L'opposé de l'abstraction effacée : .clone() fait un vrai travail.The opposite of the erased abstraction: .clone() does real work.

Le numéro précédent montrait une abstraction que le compilateur efface : la chaîne d'itérateurs ne coûte rien à l'exécution. .clone() est son exact contraire — une opération qui fait un travail bien réel, et qui ne s'évapore pas. Pour un type qui possède de la mémoire sur le tas (String, Vec, HashMap), cloner veut dire allouer un nouveau tampon et y recopier tous les octets. Venant d'un langage à GC, on n'y prête aucune attention : là-bas, « passer » un objet ne le copie pas, on partage une référence et le ramasse-miettes gère le reste. En Rust, .clone() est explicite précisément parce qu'il a un coût qu'on doit voir. Le danger est de le dégainer par réflexe — chaque fois qu'un emprunt gêne, qu'un move dérange : un petit .clone() et ça compile. Chacun est une allocation silencieuse, et le plus souvent le signe d'un emprunt qu'on n'a pas su écrire.The previous issue showed an abstraction the compiler erases: the iterator chain costs nothing at runtime. .clone() is its exact opposite — an operation that does very real work, and doesn't evaporate. For a type owning heap memory (String, Vec, HashMap), cloning means allocating a new buffer and copying all the bytes into it. Coming from a GC language, you pay it no attention: there, 'passing' an object doesn't copy it, you share a reference and the garbage collector handles the rest. In Rust, .clone() is explicit precisely because it has a cost you must see. The danger is drawing it by reflex — every time a borrow is awkward, a move is bothersome: a little .clone() and it compiles. Each one is a silent allocation, and most often the sign of a borrow you couldn't express.

let original = String::from("un assez long texte…");

let copie = original.clone();   // ALLOUE un nouveau tampon sur le tas + recopie tous les octets
// `original` et `copie` sont deux String distinctes, chacune possède SON tampon.

let n: i32 = 42;
let m = n;                      // pour un type Copy, « copier » est une copie de bits — zéro tas.
// le coût de clone() dépend du type : trivial pour Copy (i32, bool), une ALLOCATION
// pour String, Vec, HashMap… — tout ce qui possède de la mémoire sur le tas.

Le .clone() « pour faire passer » était, presque toujours, un & manquant.The .clone() 'to make it pass' was, almost always, a missing &.

Voici la surprise du numéro, et elle est presque toujours la même. On écrit une fonction qui prend un String, on l'appelle, le compilateur se plaint que la valeur est déplacée et qu'on ne peut plus s'en servir après — alors on ajoute .clone() et l'erreur disparaît. Sauf que la fonction ne faisait que lire son argument : elle n'avait jamais besoin de le posséder. Le bon geste n'était pas de dupliquer la donnée, mais de l'emprunter — prendre &str au lieu de String. Le clone qu'on a ajouté n'était pas un besoin de possession ; c'était un emprunt qu'on n'a pas su exprimer. Le compilateur ne réclamait pas une copie : il posait une question — cette fonction doit-elle posséder, ou lui suffit-il d'emprunter ? — et le .clone() réflexe est une mauvaise réponse à cette question. C'est l'écho direct du Vol 1 №3 : prends une vue, ne prends pas possession.Here's the issue's surprise, and it's almost always the same. You write a function taking a String, you call it, the compiler complains the value is moved and can't be used afterward — so you add .clone() and the error vanishes. Except the function only read its argument: it never needed to own it. The right move wasn't to duplicate the data, but to borrow it — take &str instead of String. The clone you added wasn't a need to own; it was a borrow you couldn't express. The compiler wasn't demanding a copy: it was asking a question — must this function own, or does borrowing suffice? — and the reflexive .clone() is a bad answer to it. It's the direct echo of Vol 1 №3: take a view, don't take ownership.

fn afficher(s: String) {        // prend la POSSESSION… alors qu'il ne fait que LIRE
    println!("{s}");
}

let nom = String::from("Ada");
afficher(nom.clone());          // ✕ on clone juste pour GARDER `nom` après l'appel
println!("encore : {nom}");
// sans le clone : error[E0382] — `nom` a été déplacé dans afficher(). on a « réparé »
// par une allocation, là où le compilateur demandait en réalité de DÉCIDER la possession.

La fonction prend String par valeur, donc l'appel déplace nom ; pour pouvoir l'utiliser ensuite, on clone. Mais regarde ce que fait afficher : elle lit, point. Exiger la possession d'une donnée qu'on ne fait que lire, c'est imposer à chaque appelant de céder sa valeur ou d'en payer une copie. L'allocation du clone n'achète rien — elle compense seulement une signature trop gourmande. Le coût est réel, le bénéfice nul.The function takes String by value, so the call moves nom; to use it afterward, you clone. But look at what afficher does: it reads, period. Demanding ownership of data you only read forces every caller to give up its value or pay for a copy. The clone's allocation buys nothing — it merely compensates for a too-greedy signature. The cost is real, the benefit nil.

Cow : emprunter tant qu'on peut, n'allouer qu'à l'instant où l'on mute.Cow: borrow as long as you can, allocate only the instant you mutate.

Cloner n'est pas toujours une faute : c'est le bon geste dès qu'on a réellement besoin d'une seconde possession — une copie qu'on stocke dans une struct, qu'on envoie dans un thread ou un canal (Vol 7), qui doit vivre sa propre vie indépendamment de l'original. Le problème n'est pas clone en soi, c'est le clone réflexe, pour seulement lire. Reste un cas intermédiaire, fréquent et subtil : une fonction qui, la plupart du temps, renvoie son entrée inchangée — mais qui, parfois, doit la modifier. La forcer à toujours retourner un String possédé, c'est allouer même quand rien ne change ; la forcer à toujours emprunter, c'est s'interdire de modifier. Cow — Clone on Write — tranche : c'est un type qui tient soit un emprunt (Borrowed), soit une valeur possédée (Owned), et qui ne paie l'allocation qu'au moment exact où il faut écrire. Tant qu'on lit, il emprunte ; dès qu'on mute, il copie. On ne paie que sur la branche qui en a vraiment besoin.Cloning isn't always a fault: it's the right move the moment you genuinely need a second ownership — a copy you store in a struct, send into a thread or a channel (Vol 7), that must live its own life independently of the original. The problem isn't clone itself, it's the reflexive clone, just to read. A middle case remains, common and subtle: a function that, most of the time, returns its input unchanged — but that, sometimes, must modify it. Forcing it to always return an owned String allocates even when nothing changes; forcing it to always borrow forbids modifying. Cow — Clone on Write — decides it: a type holding either a borrow (Borrowed) or an owned value (Owned), paying the allocation only at the exact moment it must write. As long as you read, it borrows; the moment you mutate, it copies. You pay only on the branch that truly needs it.

use std::borrow::Cow;

fn sans_espaces(s: &str) -> Cow<'_, str> {
    if s.contains(' ') {
        Cow::Owned(s.replace(' ', ""))   // il a fallu modifier → on ALLOUE une String
    } else {
        Cow::Borrowed(s)                 // rien à changer → on EMPRUNTE, zéro allocation
    }
}
// le cas fréquent (déjà propre) ne coûte RIEN ; on ne paie l'allocation que sur le cas
// rare qui mute vraiment. « clone on write » : emprunter tant qu'on peut, copier au besoin.

// cloner EST correct quand on a vraiment besoin d'une seconde possession :
let config = charger();
let pour_le_thread = config.clone();         // une copie qui part VIVRE ailleurs (Vol 7)
thread::spawn(move || utiliser(pour_le_thread));
utiliser(config);                            // l'original continue ici, en parallèle
// ici le clone n'est pas un contournement : les deux copies ont une vie propre.
// cloner est un choix légitime — c'est le clone RÉFLEXE, pour lire, qui est le problème.

Mettre Cow partout « pour les perfs » — et payer en complexité un gain nul.Putting Cow everywhere 'for perf' — and paying in complexity for a nil gain.

Le numéro a deux faces, et la seconde est le miroir de la première. On a vu le clone réflexe, qui cache un coût ; voici le piège inverse, plus insidieux parce qu'il se croit vertueux : truffer le code de Cow « pour éviter les allocations ». Cow n'est gratuit ni à écrire ni à lire. Dès qu'il entre dans une struct, il y traîne un paramètre de lifetime, qui contamine ensuite chaque fonction touchant cette struct (le combat du Vol 2 №3, ressuscité). Le code se hérisse de 'a, de match Borrowed/Owned, de signatures alourdies. Et tout cela pour quoi ? Si les données sont en réalité toujours possédées — comme des champs lus depuis un fichier parsé —, la branche Borrowed n'arrive jamais : on a payé toute la complexité de Cow pour zéro allocation économisée. C'est l'optimisation prématurée dans sa forme la plus pure : un coût d'ingénierie certain contre un gain de performance imaginé, que nul profil n'a réclamé.The issue has two faces, and the second mirrors the first. We saw the reflexive clone, hiding a cost; here's the inverse trap, more insidious because it thinks itself virtuous: stuffing the code with Cow 'to avoid allocations'. Cow is free neither to write nor to read. The moment it enters a struct, it drags a lifetime parameter, which then contaminates every function touching that struct (Vol 2 №3's fight, resurrected). The code bristles with 'a, with match Borrowed/Owned, with heavier signatures. And all for what? If the data is in reality always owned — like fields read from a parsed file — the Borrowed branch never happens: you paid all of Cow's complexity for zero allocation saved. It's premature optimization in its purest form: a certain engineering cost against an imagined performance gain, that no profile asked for.

// « pour éviter les allocations », on Cow-ifie tout — y compris là où c'est inutile
struct Config<'a> {
    nom: Cow<'a, str>,         // ✕ ajoute un lifetime à TOUTE la struct…
    hote: Cow<'a, str>,        //   …qui contamine chaque fonction qui touche Config
}
// mais ces champs viennent d'un fichier parsé puis possédé : ils sont TOUJOURS Owned.
// on a payé en complexité (lifetimes, match, signatures) un gain d'allocation… nul.

struct Config {
    nom: String,               // ✓ possédé, simple, aucun lifetime à propager
    hote: String,
}
// règle : possédé en permanence → String ; emprunté en permanence → &str ;
// les DEUX, sur un chemin chaud que le profil pointe → alors, et alors seulement, Cow.

Le triage est mécanique. La donnée est-elle toujours possédée par la struct ? String. Toujours empruntée à quelqu'un qui vit plus longtemps ? &str (avec son lifetime, assumé). Et vraiment les deux — parfois emprunté, parfois possédé, sur un chemin que le profil désigne comme chaud ? Alors Cow gagne sa complexité. Le piège n'est pas Cow ; c'est de l'employer sans que les deux branches existent réellement. La simplicité par défaut, l'optimisation sur preuve.The triage is mechanical. Is the data always owned by the struct? String. Always borrowed from someone living longer? &str (with its lifetime, assumed). And genuinely both — sometimes borrowed, sometimes owned, on a path the profile flags as hot? Then Cow earns its complexity. The trap isn't Cow; it's using it without both branches really existing. Simplicity by default, optimization on proof.