Advanced Types

A conditional type selects one of two types by testing assignability: T extends U ? X : Y resolves to X when T is assignable to U, and to Y otherwise. It is a compile-time if over types, evaluated by the checker and erased entirely from the emitted JavaScript.

keyof T produces the union of T's property names as literal types: for { a: number; b: string } it is 'a' | 'b'. Combined with an indexed access T[K] it types safe property lookup, as in <K extends keyof T>(o: T, k: K) => T[K]. On a type with a string index signature it widens to string | number.

A mapped type builds a new object type by iterating over a union of keys. { [K in keyof T]: T[K] } walks every key of T and gives each one a value type, so it reproduces T. Readonly<T> and Partial<T> are written exactly this way, adding a readonly or ? modifier during the mapping. The result is a fresh type computed by the checker.

A type alias may reference itself, so Json is a recursive union: type Json = string | number | boolean | null | Json[] | { [k: string]: Json }. Both self-references sit inside an array or an index signature, which defers the recursion, so the checker resolves it lazily and nesting works to any depth.

A template literal type builds string literal types out of other types, written like a JS template string but in type position. Interpolating a union expands to the cross product, so combining 'a' | 'b' with 1 | 2 yields 'a-1' | 'a-2' | 'b-1' | 'b-2'. With Capitalize and infer it can construct or even parse key names entirely at compile time.

A conditional type distributes when the checked type is a naked type parameter and the argument is a union: the check runs on each member and the results are unioned back. That is why NonNullable<string | null> yields string. Wrapping both sides in a tuple — [T] extends [U] ? X : Y — makes the operand non-naked, so the union is checked once as a whole.

infer R declares a fresh type variable at that position in the pattern and binds it to whatever the checker matches there. T extends (...a: any[]) => infer R ? R : never captures a function's return type — that is literally how ReturnType<T> is defined. infer is legal only inside a conditional's extends clause, and the bound variable is visible only in the true branch.

An as clause remaps each key: mapping K to a template literal type renames it, and mapping it to never drops the key entirely. The +/- modifiers add or remove readonly and ? — -? is exactly how Required<T> strips optionality. A homomorphic mapping, one written over keyof T, copies T's existing readonly and ? modifiers unless you override them.

Union the full shape with a shape whose keys are all optional and typed never: type AllOrNothing<T> = T | { [K in keyof T]?: never }. The second half is a mapped type over keyof T, so it tracks T automatically. Supplying only start matches neither branch — it lacks end for the first and gives never a value for the second — so the compiler rejects it.

The recursive call sits inside a template literal, so it is not in tail position: every level must stay on the instantiation stack waiting to splice its result, and the checker's depth budget runs out. Thread an accumulator so the branch returns the recursive call directly, concatenating before it recurses — the checker optimises that tail-recursive shape and unrolls it far deeper.

A homomorphic mapped type — { [K in keyof T]: … } with T a naked parameter — distributes over a union, so Partial<A | B> becomes Partial<A> | Partial<B> and each member keeps its own keys. Mapping over keyof (A | B) is not homomorphic: keyof of a union yields only the keys common to every member, so the result collapses to the shared keys and silently drops the rest.

The checker caps how deep it will instantiate a type before calling the expansion possibly infinite, and a conditional that unrolls once per element hits that cap and reports "Type instantiation is excessively deep and possibly infinite". Tail-position recursion is optimised and goes far further, so the fixes are to restructure into tail recursion, batch the work, or bound the depth with a counter.

type MyReturnType<T extends (...a: any) => any> = T extends (...a: any) => infer R ? R : never — the conditional matches T against a function shape and infer R binds the return position. Awaited<T> cannot stop there: a promise may resolve to another promise, so it re-applies itself to the inferred value — T extends PromiseLike<infer U> ? MyAwaited<U> : T — until the payload is not thenable.

Judge each type by whether it removes a real class of bug: a clever type earns its keep at a widely-used boundary, not in a leaf. Break the monoliths into small named aliases so errors and hovers report a meaningful name, add type-level tests pinning each branch, and keep the recursion shallow. Reject the casts — they trade a readability problem for a soundness one.

Keep the catalogue as const so the literals survive, then derive the key union with a recursive type that walks the object and builds dotted paths with a template literal type. An indexed access maps a path back to its message literal, and a second recursion parses that literal's placeholders into an argument object. Expect instantiation-depth and union-size limits to bite — bound the nesting, split large catalogues.

TypeScript has no higher-kinded types: a type parameter always stands for a concrete type, never an unapplied type constructor, so you cannot write F<_> and later apply it as F<string>. Abstracting over "any container" directly is impossible. Libraries emulate it by defunctionalisation — register each constructor under a string key in an interface, pass the key, apply it via an indexed access.