TypeScript Against the Runtime: What a Static Type Cannot See

// What tsc emits for typed source. The types are gone; only the runtime constructs remain.
// interface User { id: number; name: string }
// const u = JSON.parse(text) as User;
const u = JSON.parse('{"id": "42", "name": "x"}');          // `as User` erased: no check happened
console.log("erased cast let a string through:", typeof u.id);

// enum Direction { Up = 1, Down }   compiles to an IIFE building an object with a reverse mapping:
var Direction;
(function (Direction) {
  Direction[Direction["Up"] = 1] = "Up";
  Direction[Direction["Down"] = 2] = "Down";
})(Direction || (Direction = {}));
console.log("enum is an object:", JSON.stringify(Direction), "| reverse mapping:", Direction[2]);
console.log("const enum would have inlined 1 with no object at all");

// A class with parameter properties: the only place TypeScript *adds* statements.
// class P { constructor(public x: number) {} }  ->
class P { constructor(x) { this.x = x; } }
console.log("parameter property became an assignment:", Object.keys(new P(1)));

// Generics leave no trace: identity<T> is identity.
const identity = (v) => v;                                  // function identity<T>(v: T): T
console.log("generic function at runtime:", identity.length, "parameter, no type parameter");

// type Point = { x: number; y: number }. All five builders satisfy it structurally.
const builders = [
  (i) => ({ x: i, y: i }),
  (i) => ({ y: i, x: i }),                                        // different insertion order
  (i) => ({ x: i, y: i, tag: "extra" }),                          // excess property, allowed via a variable
  (i) => { const p = {}; p.x = i; p.y = i; return p; },           // built from an empty literal: a different transition path, usually a different Map
  (i) => Object.assign(Object.create({ z: 0 }), { x: i, y: i }),  // different prototype: different Map
  (i) => { class Pt { constructor(x, y) { this.x = x; this.y = y; } } return new Pt(i, i); },  // fresh class per call: fresh Map every time
];
function norm(list) { let s = 0; for (let i = 0; i < list.length; i++) { const p = list[i]; s += p.x * p.x + p.y * p.y; } return s; }   // one IC for p.x, one for p.y

function bench(label, list) {
  norm(list); norm(list);
  const t0 = performance.now();
  let r = 0; for (let k = 0; k < 8; k++) r += norm(list);
  console.log(label.padEnd(44), (performance.now() - t0).toFixed(1).padStart(7), "ms", r ? "" : "");
}
const N = 300000;
bench("one builder (monomorphic)", Array.from({ length: N }, (_, i) => builders[0](i)));
bench("builders 0-1 (polymorphic)", Array.from({ length: N }, (_, i) => builders[i % 2](i)));
bench("builders 0-4 (megamorphic)", Array.from({ length: N }, (_, i) => builders[i % 5](i)));
bench("builder 5 only: a new class per object (every Shape unique)", Array.from({ length: Math.min(N, 30000) }, (_, i) => builders[5](i)));
console.log("Every list has the same TypeScript type. Only the Shape population differs.");

// type Shape = { kind: "circle"; r: number } | { kind: "rect"; w: number; h: number } | { kind: "tri"; b: number; h: number } | ...
// Representation A: each variant its own object literal (natural TypeScript). Six variants -> six Shapes at `s.kind`.
const mkA = [
  (i) => ({ kind: 0, r: i }), (i) => ({ kind: 1, w: i, h: 2 }), (i) => ({ kind: 2, b: i, h: 3 }),
  (i) => ({ kind: 3, a: i }), (i) => ({ kind: 4, p: i, q: 1 }), (i) => ({ kind: 5, x: i, y: 1, z: 2 }),
];
// Representation B: one Shape for all variants; unused fields are undefined but present, in a fixed order.
const mkB = (i) => ({ kind: i % 6, r: i, w: i, h: 2, b: i, a: i, p: i, q: 1, x: i, y: 1, z: 2 });
function area(list) {
  let s = 0;
  for (let i = 0; i < list.length; i++) {
    const v = list[i];
    switch (v.kind) {                                             // the discriminant load: one IC for every variant
      case 0: s += 3 * v.r * v.r; break;
      case 1: s += v.w * v.h; break;
      case 2: s += v.b * v.h / 2; break;
      case 3: s += v.a * v.a; break;
      case 4: s += v.p * v.q; break;
      default: s += v.x * v.y * v.z;
    }
  }
  return s;
}
const N = 400000;
const A = Array.from({ length: N }, (_, i) => mkA[i % 6](i)), B = Array.from({ length: N }, (_, i) => mkB(i));
for (const [label, list] of [["A: six Shapes  ", A], ["B: one Shape   ", B]]) {
  area(list); area(list);
  const t0 = performance.now();
  let r = 0; for (let k = 0; k < 6; k++) r += area(list);
  console.log(label, (performance.now() - t0).toFixed(1).padStart(7), "ms", r ? "" : "");
}
console.log("Same TypeScript union either way; B trades memory (unused fields) for a monomorphic discriminant.");

// class Animal {}; class Dog extends Animal { bark() {} }; class Cat extends Animal {}
class Animal {} class Dog extends Animal { bark() { return "woof"; } } class Cat extends Animal {}
const dogs = [new Dog()];                                          // Dog[]
const animals = dogs;                                              // Animal[]: allowed, arrays are covariant in TS
animals.push(new Cat());                                           // legal on Animal[]
console.log("the Dog[] now contains:", dogs[1].constructor.name, "| dogs[1].bark:", typeof dogs[1].bark);

// Erased boundary: what a schema library reinserts.
const validateUser = (v) => {
  if (typeof v !== "object" || v === null) throw new TypeError("not an object");
  if (typeof v.id !== "number") throw new TypeError("id must be a number");
  if (typeof v.name !== "string") throw new TypeError("name must be a string");
  return v;                                                        // now the static type User is *earned*
};
try { validateUser(JSON.parse('{"id": "42", "name": "x"}')); } catch (e) { console.log("runtime validation catches it:", e.message); }
console.log("and passes good data:", validateUser(JSON.parse('{"id": 42, "name": "x"}')).id);