Mapped types & keyof, ou calculer plutôt que recopier Mapped types & keyof, or compute rather than copy

Un type dérivé, réécrit à la main, diverge de sa source. Calculé, jamais.A derived type, hand-rewritten, drifts from its source. Computed, never.

On a souvent besoin d'une variante d'un type : la même forme, mais tous les champs optionnels, ou en lecture seule, ou un sous-ensemble. Le réflexe est de la réécrire à la main — et de créer une seconde description que rien n'oblige à suivre la première. Le jour où la source gagne un champ, la copie l'ignore. TypeScript offre l'autre voie : calculer ce type à partir de l'original, pour qu'ils ne divergent jamais. C'est tout le volume — le langage dans le langage.You often need a variant of a type: the same shape, but all fields optional, or read-only, or a subset. The reflex is to rewrite it by hand — and to create a second description nothing forces to track the first. The day the source gains a field, the copy ignores it. TypeScript offers the other path: compute that type from the original, so they never diverge. That's the whole volume — the language within the language.

type User = { id: string; name: string; email: string };

// réécrit à la main — deux descriptions de la même chose à maintenir :
type UserUpdate = { id?: string; name?: string; email?: string };
// Ajoute 'role' à User → UserUpdate l'ignore en silence. Les deux divergent.

type User = { id: string; name: string; email: string };

type UserUpdate = Partial<User>;   // CALCULÉ depuis User — ne dérive jamais
// Ajoute 'role' à User → UserUpdate gagne 'role?' automatiquement.

Partial, Readonly, Record ne sont pas magiques — ce sont des boucles sur les clés.Partial, Readonly, Record aren't magic — they're loops over keys.

On utilise les utility types comme des primitives offertes par le langage. Surprise en soulevant le capot : Partial<T> est littéralement { [K in keyof T]?: T[K] }. Trois symboles. Aucune magie, aucun traitement spécial du compilateur : juste une itération sur les clés de T, qui réécrit chaque propriété. Readonly et Required : bâtis sur le même [K in keyof T]. Pick et Record bouclent sur des clés qu'on leur donne ([P in K]), et Omit n'est qu'un Pick des clés restantes. Comprendre la boucle, c'est pouvoir écrire les siens.People use utility types as language-given primitives. Surprise, lifting the hood: Partial<T> is literally { [K in keyof T]?: T[K] }. Three symbols. No magic, no special compiler handling: just an iteration over T's keys, rewriting each property. Readonly and Required: built on the same [K in keyof T]. Pick and Record loop over keys you hand them ([P in K]), and Omit is just a Pick of the remaining keys. Understand the loop, and you can write your own.

type UserUpdate = Partial<User>;
//   ≡ { id?: string; name?: string; email?: string }

type Frozen = Readonly<User>;
//   ≡ { readonly id: string; readonly name: string; readonly email: string }

Partial rend tout optionnel, Readonly tout immuable. On les lit comme des mots-clés — pratiques, opaques. Mais ce ne sont pas des mots-clés : ce sont des types ordinaires, définis dans lib.d.ts, qu'on pourrait réécrire soi-même.Partial makes everything optional, Readonly everything immutable. You read them as keywords — handy, opaque. But they aren't keywords: they're ordinary types, defined in lib.d.ts, that you could rewrite yourself.

Itérer sur keyof T, lire T[K], poser ou retirer un modificateur.Iterate over keyof T, read T[K], add or strip a modifier.

Quatre pièces, déjà toutes croisées. keyof T (Vol 5.2) est l'union des clés. [K in keyof T] itère K sur cette union. T[K] est le type de la valeur à la clé K. Et les modificateurs ? et readonly s'ajoutent — ou se retirent, avec le préfixe -. On peut aussi transformer la valeur elle-même (T[K] | null). Avec ces briques, on écrit n'importe quelle transformation de forme — y compris partir d'une union de clés nue, comme le fait Record.Four pieces, all already met. keyof T (Vol 5.2) is the key union. [K in keyof T] iterates K over that union. T[K] is the value type at key K. And the ? and readonly modifiers add — or strip, with the - prefix. You can also transform the value itself (T[K] | null). With these bricks, you write any shape transformation — including starting from a bare key union, as Record does.

type Nullable<T> = { [K in keyof T]: T[K] | null };   // transforme la VALEUR
type Mutable<T>  = { -readonly [K in keyof T]: T[K] };  // RETIRE readonly (-)
type Required<T> = { [K in keyof T]-?: T[K] };          // RETIRE l'optionnel (-?)

// Record part de zéro : il MAPPE une union de clés vers une valeur.
type Record<K extends keyof any, V> = { [P in K]: V };

type Flags = Record<"admin" | "user", boolean>;
//   ≡ { admin: boolean; user: boolean }

Dériver par confort d'une source trop large couple ce qui devrait rester séparé.Deriving for convenience from a too-wide source couples what should stay apart.

Le mapped type n'a de valeur que si la source est vraiment la vérité de la variante. Le piège : dériver d'une source trop large parce que c'est sous la main. Partial<User> pour un formulaire d'édition a l'air parfait — jusqu'à ce qu'on réalise qu'il rend éditables l'id et le createdAt posés par le serveur. La dérivation a propagé des champs qu'on ne voulait jamais offrir à l'édition. Calculer, oui — mais à partir de la bonne source, celle qui exprime l'intention.A mapped type is only worth it if the source is genuinely the truth of the variant. The trap: deriving from a too-wide source because it's at hand. Partial<User> for an edit form looks perfect — until you realize it makes the server-set id and createdAt editable. The derivation propagated fields you never meant to offer for editing. Compute, yes — but from the right source, the one that expresses intent.

type User = {
  id: string; createdAt: Date;     // ← posés par le serveur, JAMAIS éditables
  name: string; email: string;
};

type EditableUser = Partial<User>;   // ✗ dérive par confort de la source ENTIÈRE
// Le formulaire laisse maintenant éditer id et createdAt. Un champ serveur
// ajouté à User devient éditable, en silence. La dérivation a couplé trop large.

La dérivation fonctionne trop bien : elle suit User fidèlement, y compris ses champs serveur. Le lien « pas de dérive » est réel, mais il couple des choses qui ne devraient pas bouger ensemble — l'édition et la persistance. Le contre-exemple : dériver parce que c'est commode, pas parce que la source est la bonne.The derivation works too well: it tracks User faithfully, including its server fields. The "no drift" link is real, but it couples things that shouldn't move together — editing and persistence. The counter-example: deriving because it's convenient, not because the source is the right one.