Code, der lesenswert ist.

type Brand<K, T> = K & { __brand: T };
 
type USD = Brand<number, "USD">;
type EUR = Brand<number, "EUR">;
 
const usd = 10 as USD;
const eur = 10 as EUR;
 
function addUSD(a: USD, b: USD): USD {
  return (a + b) as USD;
}
 
// Error: Argument of type 'EUR' is not assignable to 'USD'
// addUSD(usd, eur);

type ExtractParams<T extends string> = 
  T extends `${string}:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof ExtractParams<Rest>]: string }
    : T extends `${string}:${infer Param}`
    ? { [K in Param]: string }
    : {};
 
const route = "/user/:id/posts/:postId";
type RouteParams = ExtractParams<typeof route>;
// Result: { id: string; postId: string; }

type UnionToIntersection<U> = 
  (U extends any ? (k: U) => void : never) extends 
  ((k: infer I) => void) ? I : never;
 
type Result = UnionToIntersection<{ a: 1 } | { b: 2 }>;
// Result: { a: 1 } & { b: 2 }

class TempFile implements Disposable {
  constructor(public path: string) {}
  [Symbol.dispose]() {
    console.log(`Deleting ${this.path}`);
  }
}
 
function process() {
  using file = new TempFile("/tmp/log.txt");
  // File is automatically disposed at end of scope
}

type Shape = { type: "circle" } | { type: "square" };
 
function getArea(shape: Shape) {
  switch (shape.type) {
    case "circle": return Math.PI;
    case "square": return 1;
    default:
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

function assertIsString(val: any): asserts val is string {
  if (typeof val !== "string") {
    throw new Error("Not a string!");
  }
}
 
function process(input: unknown) {
  assertIsString(input);
  // input is now narrowed to 'string' for the rest of the scope
  console.log(input.toUpperCase());
}

function loggedMethod<This, Args extends any[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
) {
  const methodName = String(context.name);
  return function (this: This, ...args: Args): Return {
    console.log(`Calling ${methodName}`);
    return target.call(this, ...args);
  };
}

type Colors = "red" | "green" | "blue";
type RGB = [number, number, number];
 
const palette = {
  red: [255, 0, 0],
  green: "#00ff00",
  blue: [0, 0, 255]
} satisfies Record<Colors, RGB | string>;
 
// palette.red is inferred as [number, number, number], not string | RGB
const redValue = palette.red[0];