Slices, ou regarder sans copier ni posséder Slices, or looking without copying or owning

Une fenêtre sur une donnée. Ni copie, ni possession.A window onto data. Neither copy nor ownership.

Le move déplace, l'emprunt prête la donnée entière. La slice est le troisième geste : emprunter une fenêtre — une portion contiguë — d'une collection, sans la copier ni la posséder. &str est une vue dans un String ; &[T] une vue dans un Vec. Ce n'est qu'un pointeur et une longueur : regarder une sous-partie ne coûte rien.The move relocates, the borrow lends the whole value. The slice is the third gesture: borrowing a window — a contiguous portion — of a collection, without copying or owning it. &str is a view into a String; &[T] a view into a Vec. It's just a pointer and a length: looking at a sub-part costs nothing.

let phrase = String::from("hello world");

let hello = &phrase[0..5];   // une VUE sur les 5 premiers octets
let world = &phrase[6..11];  // une autre vue, même donnée sous-jacente

println!("{hello} / {world}");   // hello / world — zéro copie, zéro alloc

Demander un String quand on voulait juste lire.Asking for a String when you only wanted to read.

Venant d'un langage à GC, passer une chaîne « ne coûte rien » : tout est référence implicite. En Rust, écrire fn salue(nom: String) dit littéralement « donne-moi la possession de ton String ». L'appelant doit céder le sien — ou en fabriquer un par clone. Une signature trop gourmande, et tout le code autour paie.Coming from a GC language, passing a string 'costs nothing': everything is an implicit reference. In Rust, writing fn salue(nom: String) literally says 'hand me ownership of your String'. The caller must give theirs up — or fabricate one by cloning. One greedy signature, and all the surrounding code pays.

fn salue(nom: String) {        // exige de POSSÉDER un String
    println!("Salut {nom}");
}

salue(String::from("Ada"));    // ok
salue("Bob");                  // ✕ "Bob" est &str, pas String
let n = String::from("Cléo");
salue(n);                      // ok, mais n est MOVED — on ne l'a plus
salue(n);                      // ✕ error[E0382]: n a déjà été donné

La fonction ne fait que lire nom — mais sa signature exige la possession. Conséquence : un littéral ne passe pas, et toute variable passée est consommée. Pour la réutiliser, on en vient à cloner « pour que ça passe » — le piège des numéros 1 et 2, importé par une seule mauvaise signature.The function only reads nom — yet its signature demands ownership. The fallout: a literal won't pass, and any variable passed is consumed. To reuse it, you end up cloning 'to make it pass' — the trap from issues 1 and 2, imported by one bad signature.

Un pointeur, une longueur — et la déréférence qui relie tout.A pointer, a length — and the deref that ties it together.

Sous le capot, une slice est un fat pointer : deux mots — l'adresse du premier élément, et le nombre d'éléments. Rien d'autre. C'est ce qui rend &str strictement plus général que &String : un &String peut toujours devenir un &str (par déréférence automatique), l'inverse n'est pas vrai. Accepter une vue, c'est accepter le plus de monde possible avec le moins d'exigence.Under the hood, a slice is a fat pointer: two words — the address of the first element, and the count of elements. Nothing else. That's what makes &str strictly more general than &String: a &String can always become a &str (by auto-deref), the reverse isn't true. Accepting a view means accepting the widest set of callers with the least demand.

Le fat pointer : deux mots, zéro donnéeThe fat pointer: two words, zero data

La déréférence : pourquoi &str avale &StringDeref coercion: why &str swallows &String

Quand une fonction attend &str et qu'on lui donne &String, Rust insère silencieusement la conversion : c'est la deref coercion. Idem pour &Vec<T> → &[T]. Conséquence pratique : un paramètre &str accepte le littéral, le &String, et toute sous-tranche — un seul type d'entrée, trois sources.When a function expects &str and you hand it a &String, Rust silently inserts the conversion: that's deref coercion. Same for &Vec<T> → &[T]. Practical upshot: a &str parameter accepts the literal, the &String, and any sub-slice — one input type, three sources.

fn premier_mot(s: &str) -> &str {
    s.split(' ').next().unwrap_or("")
}

let owned = String::from("hello world");

premier_mot(&owned);       // &String  → &str   (déréf automatique)
premier_mot("hello world");// &str             (littéral, déjà une vue)
premier_mot(&owned[6..]);  // &str             (une sous-tranche)

// &Vec<T> se déréférence de même en &[T] :
fn somme(v: &[i32]) -> i32 { v.iter().sum() }
let nums = vec![1, 2, 3];
somme(&nums);              // &Vec<i32> → &[i32]
somme(&nums[1..]);         // &[i32]

Prendre String « par habitude » là où &str suffisait.Taking String 'out of habit' where &str would do.

Le réflexe vient d'autres langages : un paramètre de type « chaîne », on écrit le type chaîne — String. Mais en Rust, String dit « je veux la possession ». Si la fonction ne fait que lire, cette exigence ne sert à rien : elle force l'appelant à céder sa donnée ou à cloner, refuse les littéraux, et couple toute l'API à une allocation tas dont elle n'avait pas besoin. Le coût n'est pas dans la fonction — il est chez tous ceux qui l'appellent.The reflex comes from other languages: a 'string' parameter, so you write the string type — String. But in Rust, String says 'I want ownership'. If the function only reads, that demand buys nothing: it forces the caller to give up their data or clone, refuses literals, and couples the whole API to a heap allocation it never needed. The cost isn't in the function — it's on everyone who calls it.

// Une fonction qui ne fait que LIRE, mais exige de posséder
fn est_palindrome(mot: String) -> bool {
    let inverse: String = mot.chars().rev().collect();
    mot == inverse
}

let titre = String::from("kayak");
est_palindrome(titre.clone());  // clone « pour que ça passe »
est_palindrome(titre);          // ou move : on perd titre
// est_palindrome("ressasser") ne compile même pas : &str ≠ String

La fonction lit mot, compare, et c'est tout — elle n'a aucune raison de le posséder. Pourtant sa signature l'exige, et le coût se propage : l'appelant clone (une allocation entière pour un test booléen), ou cède sa variable et la perd, ou n'a tout simplement pas de String sous la main et reste bloqué. Une mauvaise signature taxe tout le code autour d'elle.The function reads mot, compares, and that's all — it has no reason to own it. Yet its signature demands it, and the cost spreads: the caller clones (a whole allocation for a boolean test), or surrenders their variable and loses it, or simply has no String on hand and is stuck. A bad signature taxes all the code around it.

// La même logique, mais on emprunte une vue
fn est_palindrome(mot: &str) -> bool {
    let inverse: String = mot.chars().rev().collect();
    mot == inverse
}

let titre = String::from("kayak");
est_palindrome(&titre);       // &String → &str, titre intact
est_palindrome("ressasser");  // littéral, directement
est_palindrome(&titre[1..4]); // une sous-tranche — zéro alloc

Un seul caractère change — String devient &str — et tout se débloque : le &String est accepté par déréférence, le littéral passe directement, la sous-tranche aussi, et titre survit à l'appel. Zéro clone, zéro allocation, plus d'appelants servis. La fonction n'a rien perdu : elle ne faisait que lire, elle ne demande plus que de lire.One character changes — String becomes &str — and everything unlocks: the &String is accepted by deref, the literal passes directly, the sub-slice too, and titre survives the call. Zero clone, zero allocation, more callers served. The function lost nothing: it only ever read, now it only asks to read.