Génériques & inférence, ou une relation, pas une inconnue Generics & inference, or a relation, not an unknown

Un générique n'est pas « un type qu'on ignore ». C'est une relation entre des types.A generic isn't "a type you don't know". It's a relation between types.

Le Vol 4 parlait d'abandonner le type. Le générique fait l'inverse : il le garde, et le fait voyager. Une fonction qui doit marcher pour plusieurs types tombe vite dans le piège du any — qui rompt tout lien entre ce qui entre et ce qui sort, et débranche la vérification. <T> dit autre chose : « quel que soit le type d'élément, le type de retour est le même ». Ce n'est pas une inconnue, c'est un fil tendu entre deux positions.Vol 4 was about abandoning the type. The generic does the opposite: it keeps it, and makes it travel. A function meant to work for several types quickly falls into the any trap — which severs any link between what comes in and what goes out, and unplugs checking. <T> says something else: 'whatever the element type, the return type is the same'. It's not an unknown, it's a thread strung between two positions.

function first(arr: any[]): any {   // any : aucun lien entre l'entrée et la sortie
  return arr[0];
}

const u = first(users);   // u : any  ← le type d'élément est perdu
u.nme;                    // ✗ faute de frappe — aucune erreur, any déteint (Vol 4)

function first<T>(arr: T[]): T | undefined {   // <T> RELIE : type d'élément = type de retour
  return arr[0];                                // (| undefined : le tableau peut être vide)
}

const u = first(users);   // u : User | undefined  ← T inféré à User au site d'appel
u?.nme;                   // ✗ 'nme' n'existe pas sur User — attrapé

On n'écrit presque jamais <T> à l'appel. TypeScript le déduit de l'argument.You almost never write <T> at the call. TypeScript deduces it from the argument.

Venant de Java ou C#, on s'attend à écrire first<User>(users). En TypeScript, c'est rare : on appelle first(users), et le compilateur lit l'argument pour en déduire que T vaut User. Le paramètre de type se remplit au site d'appel, automatiquement. Et comme le même T peut apparaître à plusieurs endroits, il les relie : passer des arguments qui ne concordent pas devient une erreur. L'inférence et la relation sont les deux faces du même mécanisme.Coming from Java or C#, you expect to write first<User>(users). In TypeScript, that's rare: you call first(users), and the compiler reads the argument to deduce that T is User. The type parameter fills in at the call site, automatically. And since the same T can appear in several places, it ties them together: passing mismatched arguments becomes an error. Inference and relation are two faces of the same mechanism.

const a = first(users);       // T = User    ← inféré de l'argument
const b = first([1, 2, 3]);   // T = number  ← inféré
const c = first(["x", "y"]);  // T = string  ← un seul code, trois types exacts
// on n'a jamais écrit first<User> : TS lit l'argument et remplit T tout seul

Le compilateur regarde ce qu'on passe et en déduit T : un User[] donne T = User, un number[] donne T = number. Tu écris le code une fois ; l'inférence le spécialise à chaque appel, sans jamais perdre le type exact en route.The compiler looks at what you pass and deduces T: a User[] gives T = User, a number[] gives T = number. You write the body once; inference specializes it at each call, never losing the exact type on the way.

Un paramètre — mais au niveau type. Le site d'appel fournit l'argument.A parameter — but at the type level. The call site supplies the argument.

Le mécanisme tient en une analogie : <T> est un paramètre, comme (x) en est un, sauf qu'il vit au niveau des types. À l'appel, on fournit l'argument — explicitement (rare) ou par inférence (presque toujours). Plusieurs paramètres sont possibles : <K, V> pour une Map. Et ce n'est pas une curiosité : Array<T>, Map<K,V>, Promise<T>, Set<T> — toute la bibliothèque standard est faite de relations génériques que tu utilises déjà sans y penser.The mechanism is one analogy: <T> is a parameter, just as (x) is, except it lives at the type level. At the call, you supply the argument — explicitly (rare) or by inference (almost always). Several parameters are possible: <K, V> for a Map. And it's no curiosity: Array<T>, Map<K,V>, Promise<T>, Set<T> — the whole standard library is made of generic relations you already use without thinking.

// Un générique est une fonction au niveau TYPE : <…> = ses paramètres.
function lookup<K, V>(map: Map<K, V>, key: K): V | undefined {
  return map.get(key);
}                       // K et V sont fournis au site d'appel, comme des arguments

const score = lookup(byName, "ana");   // K = string, V = number — inférés ensemble

// Toute la bibliothèque standard est bâtie là-dessus :
const xs: Array<number>   = [1, 2, 3];      // Array<T>
const m:  Map<string, User> = new Map();    // Map<K, V>
const p:  Promise<User>   = fetchUser();    // Promise<T>
const s:  Set<string>     = new Set();      // Set<T>

Le <T> qui n'apparaît qu'une fois ne relie rien — c'est un as déguisé.A <T> that appears only once relates nothing — it's an as in disguise.

Le faux générique a l'air savant et ne prouve rien. Le test est mécanique : compte les positions où T apparaît. S'il n'est qu'à un seul endroit — souvent le seul retour — il ne relie aucune entrée à aucune sortie : le compilateur n'a rien d'où l'inférer, et l'appelant le choisit lui-même. parseJson<User>(raw) n'est alors qu'un JSON.parse(raw) as User avec des chevrons : le mensonge du Vol 4, rhabillé en polymorphisme.The fake generic looks clever and proves nothing. The test is mechanical: count the positions where T appears. If it's in only one place — often the return alone — it relates no input to any output: the compiler has nothing to infer it from, and the caller picks it themselves. parseJson<User>(raw) is then just a JSON.parse(raw) as User with angle brackets: Vol 4's lie, dressed up as polymorphism.

function parseJson<T>(s: string): T {   // ✗ T n'apparaît QU'au retour
  return JSON.parse(s);                  // rien dans les params ne détermine T
}

const u = parseJson<User>(raw);   // u : User — mais RIEN n'a été vérifié
u.name.trim();                    // 💥 c'est JSON.parse(raw) as User, déguisé en <>

Aucun paramètre ne porte T : le compilateur ne peut pas l'inférer, donc l'appelant l'affirme (<User>) sans le moindre contrôle. Le générique ne crée ici aucun lien — il n'est qu'une façon plus cérémonieuse d'écrire as. Le contre-exemple obligatoire : un <T> qui ne relie rien.No parameter carries T: the compiler can't infer it, so the caller asserts it (<User>) with zero checking. The generic creates no link here — it's just a more ceremonious way to write as. The mandatory counter-example: a <T> that relates nothing.