Contraintes (extends) & valeurs par défaut, ou de quelle capacité ai-je besoin ? Constraints (extends) & defaults, or which capability do I need?

Sur un <T> libre, on ne peut presque rien faire. Et c'est correct.On a free <T>, you can do almost nothing. And that's correct.

Le numéro précédent faisait voyager le type ; celui-ci veut s'en servir. Et là, surprise : un T totalement libre interdit d'appeler .length ou de lire .name — parce qu'on ignore tout de ses capacités. Le réflexe paresseux est de retomber dans any (et de tout perdre). Le bon geste : borner le générique à exactement ce dont on a besoin — T extends { length: number } —, ce qui débloque la capacité sans sacrifier le type précis.The previous issue made the type travel; this one wants to use it. And here's the surprise: a fully free T forbids calling .length or reading .name — because you know nothing of its capabilities. The lazy reflex is to fall back to any (and lose everything). The right move: bound the generic to exactly what you need — T extends { length: number } — which unlocks the capability without sacrificing the precise type.

function longest<T>(a: T, b: T): T {
  return a.length >= b.length ? a : b;   // ✗ 'length' n'existe pas sur le type 'T'
}                                         // un T libre n'a AUCUNE capacité connue

function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;   // ✓ T a AU MOINS une length
}

longest([1, 2], [3]);     // T = number[]  → renvoie number[], pas { length }
longest("aaa", "bb");     // T = string    → renvoie string, type exact préservé

La liberté de T est une impuissance. La contrainte est ce qui le rend capable.The freedom of T is a powerlessness. The constraint is what makes it capable.

On arrive en croyant qu'un générique non contraint est le plus puissant — il accepte tout ! C'est l'inverse. Plus T est libre, moins on peut en faire : si je ne sais rien de lui, je ne peux ni lire une propriété, ni l'appeler, ni l'additionner. C'est exactement la leçon d'unknown (Vol 4), au niveau d'un paramètre de type. La contrainte ne bride pas T : elle débloque précisément la capacité qu'on a déclarée — et seulement celle-là.You arrive thinking an unconstrained generic is the most powerful — it accepts everything! It's the opposite. The freer T is, the less you can do with it: if I know nothing about it, I can't read a property, call it, or add it. That's exactly unknown's lesson (Vol 4), at the level of a type parameter. The constraint doesn't curb T: it unlocks precisely the capability you declared — and only that one.

function f<T>(x: T) {
  x.length;     // ✗ pas de length sur T
  x.name;       // ✗ pas de name
  x.toFixed();  // ✗ rien : T peut être N'IMPORTE QUOI
}               // plus T est libre, MOINS on peut en faire

Le compilateur n'est pas tatillon : il ignore vraiment ce qu'est T, donc il ne peut garantir aucune opération. Chaque refus est la même question qu'avec unknown — « es-tu sûr que ça a une length ? » —, mais posée une fois pour toutes, dans la signature.The compiler isn't being fussy: it genuinely doesn't know what T is, so it can guarantee no operation. Each refusal is the same question as with unknown — "are you sure it has a length?" — but asked once and for all, in the signature.

extends borne, keyof énumère, T[K] relie — et = donne un défaut.extends bounds, keyof enumerates, T[K] relates — and = gives a default.

Quatre outils. extends C exige que T soit assignable à C. keyof T est l'union littérale des clés de T. T[K] est le type à la clé K (avec K extends keyof T). Et T = Default fournit une valeur de repli quand ni l'inférence ni l'appel ne donnent T. Mis ensemble, ils produisent le chef-d'œuvre des génériques contraints : un accès à une propriété entièrement typé, qui refuse les clés qui n'existent pas.Four tools. extends C requires T to be assignable to C. keyof T is the literal union of T's keys. T[K] is the type at key K (with K extends keyof T). And T = Default supplies a fallback when neither inference nor the call provides T. Together they produce the masterpiece of constrained generics: a fully typed property access that refuses keys which don't exist.

function get<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}                  // K est contraint aux clés de T ; le retour est le type À cette clé

const u = { name: "Ana", age: 30 };
get(u, "name");    // string  — K = "name", retour T["name"]
get(u, "age");     // number  — K = "age",  retour T["age"]
get(u, "email");   // ✗ "email" n'est pas une clé de u

type Box<T = string> = { value: T };

const a: Box = { value: "x" };        // T par défaut = string
const b: Box<number> = { value: 42 }; // T fourni explicitement

Sur-contraindre rigidifie autant que sous-contraindre fragilise.Over-constraining rigidifies as much as under-constraining weakens.

« Juste assez » a deux falaises. À gauche, le générique trop libre qui ne relie rien — un any avec un chapeau, vu au numéro précédent. À droite, le piège propre au 5.2 : contraindre à plus que ce dont on se sert. Borner T à User entier alors qu'on ne lit que .id rejette tout objet qui aurait un id sans être un User — un order, un littéral de test, un mock. On a confondu « ce que je manipule » avec « ce dont j'ai besoin ».'Just enough' has two cliffs. On the left, the too-free generic that relates nothing — an any with a hat, seen last issue. On the right, the trap specific to 5.2: constraining to more than you use. Bounding T to a whole User when you only read .id rejects every object that has an id without being a User — an order, a test literal, a mock. You confused 'what I pass' with 'what I need'.

// On ne lit que .id — mais on contraint à User tout entier :
function idOf<T extends User>(x: T): string {
  return x.id;
}

idOf(currentUser);              // ✓
idOf({ id: "x" });             // ✗ pas un User complet — rejeté pour RIEN
idOf(order);                    // ✗ order a pourtant un id… mais n'est pas un User

Exiger T extends User pour ne lire qu'un .id, c'est demander un passeport pour vérifier une initiale. Tout objet qui a la capacité requise mais pas le type entier est rejeté sans raison — la fonction perd sa réutilisabilité, et c'est le contraire du polymorphisme qu'on visait.Requiring T extends User just to read a .id is demanding a passport to check an initial. Any object that has the required capability but not the whole type is rejected for no reason — the function loses its reusability, the opposite of the polymorphism you aimed for.