Le coût de la compilation, ou gratuit au runtime n'est pas gratuit The compile cost, or free at runtime isn't free

Les types s'effacent à l'exécution — mais ils s'exécutent à la compilation.Types erase at runtime — but they run at compile time.

On répète depuis le Vol 2 que les types s'effacent : zéro coût au runtime. C'est vrai — et c'est la moitié de l'histoire. Au moment de la compilation, le vérificateur exécute réellement tes types : il déroule les récursions, multiplie les unions, compare des structures. Un type trop intelligent ne ralentit pas ton programme, il ralentit tsc et l'éditeur — une seconde de latence à chaque survol, une autocomplétion qui rame. Le prix existe ; il a juste changé d'endroit.Since Vol 2 we've repeated that types erase: zero runtime cost. True — and it's half the story. At compile time, the checker actually runs your types: it unrolls recursions, multiplies unions, compares structures. A too-clever type doesn't slow your program, it slows tsc and the editor — a second of lag on every hover, sluggish autocomplete. The price exists; it just moved.

// Un type récursif élégant — appliqué à une config profonde :
type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

type Draft = DeepPartial<HugeNestedConfig>;   // 12 niveaux d'imbrication
// au survol : "..." après une seconde ; l'autocomplétion rame à chaque frappe

// Le sous-ensemble réellement éditable, écrit à plat :
type Draft = {
  title?: string;
  theme?: { mode?: "light" | "dark" };
};
// au survol : instantané ; tsc ne calcule rien ; on lit la forme d'un coup d'œil

Le vérificateur est un interprète. Tes types sont un programme qu'il fait tourner.The checker is an interpreter. Your types are a program it runs.

La surprise vient de la fausse sécurité de l'effacement : « les types disparaissent, donc ils sont gratuits ». Gratuits à l'exécution, oui. Mais le système de types est un petit langage (Vol 6), et tsc en est l'interprète : il déroule les récursions, matérialise les produits cartésiens des templates, compare des structures entières. Un type complexe est un calcul, avec un coût de calcul. La différence avec un programme normal : ce calcul tourne à chaque frappe dans ton éditeur, pas une fois en production.The surprise comes from erasure's false comfort: 'types vanish, so they're free'. Free at runtime, yes. But the type system is a little language (Vol 6), and tsc is its interpreter: it unrolls recursions, materializes templates' cartesian products, compares whole structures. A complex type is a computation, with a computation cost. The difference from a normal program: that computation runs on every keystroke in your editor, not once in production.

// À l'exécution : rien. Les deux compilent vers le même JavaScript.
const draft: DeepPartial<Config> = {};
const draft2: { title?: string } = {};
// node ne voit aucune différence — le type a disparu (Vol 2). Coût runtime : nul.

Le type le plus alambiqué et le plus simple produisent le même JavaScript : à l'exécution, ils n'existent plus (Vol 2). C'est cette gratuité-là, réelle, qui endort — on en conclut, à tort, qu'un type complexe ne coûte rien du tout.The most convoluted and the simplest type produce the same JavaScript: at runtime, they no longer exist (Vol 2). It's that real free-ness that lulls — you wrongly conclude a complex type costs nothing at all.

Mesurer avant d'accuser : --extendedDiagnostics nomme le coupable.Measure before blaming: --extendedDiagnostics names the culprit.

On ne devine pas la lenteur, on la mesure. tsc --extendedDiagnostics donne trois chiffres clés : le nombre de Types, le nombre d'Instantiations (combien de fois les génériques se déroulent — souvent le vrai coupable), et le Check time. tsc --generateTrace produit un profil visualisable, qui pointe le type exact qui mange les secondes. Les causes sont presque toujours les mêmes : récursion profonde, produits cartésiens de templates, conditionnels imbriqués, intersections de très gros types. Connaître l'outil, c'est cesser d'accuser au hasard.You don't guess slowness, you measure it. tsc --extendedDiagnostics gives three key numbers: the Types count, the Instantiations count (how many times generics unroll — often the real culprit), and the Check time. tsc --generateTrace produces a viewable profile that points to the exact type eating the seconds. The causes are almost always the same: deep recursion, template cartesian products, nested conditionals, intersections of very large types. Knowing the tool means you stop blaming at random.

tsc --extendedDiagnostics
//   Types:            128 304     ← combien de types matérialisés
//   Instantiations:   3 921 556   ← combien de fois les génériques sont déroulés (le coupable)
//   Check time:       7.8 s        ← le temps réel passé à vérifier

tsc --generateTrace ./trace
//   produit un profil ouvrable dans un visualiseur — quel type mange les secondes

// Les sources classiques de lenteur :
type A = DeepRecurse<Big>;            // récursion profonde, redéroulée partout
type B = `${U1}-${U2}-${U3}`;          // produit cartésien de grandes unions (6.3)
type C = CondPyramid<X>;              // conditionnels imbriqués (6.2)
type D = Huge1 & Huge2 & Huge3;       // intersections de très gros objets

Le type si malin que tsc renonce — parfois sans le dire.The type so clever tsc gives up — sometimes without saying so.

Le contre-exemple : pousser un type calculé si loin qu'il dépasse la limite de profondeur d'instanciation. Deux issues, toutes deux mauvaises. Soit tsc refuse : « Type instantiation is excessively deep and possibly infinite » — et le code ne compile plus. Soit, plus insidieux, au-delà d'une certaine profondeur de comparaison, il cesse de descendre et suppose les types compatibles, sans erreur visible : on croit avoir un type fort, on a un mensonge lent. La leçon du volume, à son comble : la prouesse au niveau type se paie en secondes — et parfois en garantie perdue.The counter-example: pushing a computed type so far it exceeds the instantiation-depth limit. Two outcomes, both bad. Either tsc refuses: 'Type instantiation is excessively deep and possibly infinite' — and the code stops compiling. Or, more insidiously, past a certain comparison depth, it stops descending and assumes the types compatible, with no visible error: you think you have a strong type, you have a slow lie. The volume's lesson at its peak: type-level feats are paid in seconds — and sometimes in lost guarantee.

// Un type si profond que TS finit par RENONCER à la précision :
type Flatten<T> = T extends [infer H, ...infer R] ? [H, ...Flatten<R>] : [];
type X = Flatten<VeryLongTuple>;   // au-delà de la limite de profondeur :
//   "Type instantiation is excessively deep and possibly infinite."
//   …ou pire, dans une comparaison trop profonde : TS cesse de descendre et SUPPOSE
//   les types compatibles — une vérification abandonnée, sans un mot

La récursion sans borne franchit la limite : ou bien tsc casse, ou bien il renonce à la précision sans le dire — au-delà d'une profondeur, il suppose les types compatibles au lieu de les comparer, et la garantie qu'on croyait tenir s'est évaporée à l'insu de tous. Lent et faux : le pire des deux.Unbounded recursion crosses the limit: either tsc breaks, or it abandons precision without saying so — past a depth, it assumes the types compatible instead of comparing them, and the guarantee you thought you held evaporated unbeknownst to all. Slow and wrong: the worst of both.