Utility & Mapped Types

They are set operations over unions. Exclude<T, U> drops every member of T assignable to U, Extract<T, U> keeps only those members, and NonNullable<T> removes null and undefined from T.

ReturnType<typeof createUser> gives the type. In a type position, typeof turns the value createUser into its function type, which ReturnType then unwraps. ReturnType<createUser> fails because createUser is a value, not a type.

Partial<T> makes every property of T optional, Required<T> makes every property mandatory, and Readonly<T> makes every property read-only. All three keep T's keys and property types, flip one modifier, and disappear when the code is compiled to JavaScript.

Pick<T, K> builds an object type containing only the properties of T named in K; Omit<T, K> contains every property of T except those. Deriving keeps one source of truth, so editing T updates both types automatically.

Record<K, V> builds an object type whose keys come from K and whose values are all V. It is defined as the mapped type { [P in K]: V }, so a string key produces an open index signature while a union of literals produces exactly those required properties.

keyof produces the union of a type's property keys as literal types: keyof User is "id" | "name". It operates on types only, so for a value you write keyof typeof config. Nothing of it survives compilation.

Indexed access reads a property's type by key: User['id'] is number, User[keyof User] is the union of all property types (number | string | undefined), and (typeof roles)[number] is the union of the tuple's elements, 'admin' | 'user'.

Write type Mutable<T> = { -readonly [K in keyof T]: T[K] }. In a mapped type the minus prefix strips a modifier the source property carried and plus adds one; both prefixes apply to readonly and to the optional marker ?.

keyof (A | B) is "id" — only the keys every member has. keyof distributes over the union and the results are intersected, because a value of a union type is guaranteed to carry just the shared properties. The mirror case: keyof (A & B) is "id" | "name" | "age".

The as clause renames each key while the mapped type iterates, emitting the property under the computed name instead of K. A key whose clause evaluates to never produces no property at all, which is how mapped types filter keys out.

A conditional type chooses between two types by testing assignability: if T is assignable to string the type becomes 'yes', otherwise 'no'. IsString<'abc'> resolves to 'yes', because the literal type 'abc' is assignable to string.

A conditional type whose checked type is a bare type parameter distributes: TypeScript applies it to each union member separately and unions the results. ToArray runs once on string and once on number, producing string[] | number[].

The result is 'yes'. In a conditional type, extends asks whether the left type is assignable to the right one, and an object type with an extra property is assignable to one that requires fewer. No declared inheritance is involved.

infer declares a type variable inside the extends clause of a conditional type, letting the compiler pattern-match a shape and capture whatever sits in that slot. The captured variable is in scope only in the true branch.

The conditional distributes over the union: string yields true, number yields false, and true | false is exactly how boolean is defined. Wrapping both sides in one-element tuples, [T] extends [string], disables distribution and returns false.

Any string that begins with "hello " — the placeholder matches any string, so "hello world" is assignable but "hi" is not. The type is a narrower subtype of string, and the match is checked only at compile time.

It is the four-member union "light-red" | "light-blue" | "dark-red" | "dark-blue". A union placed in a placeholder distributes, so the result is the cross-product of every placeholder's members.

It gives "b-c". A placeholder followed by literal text matches as little as possible, so Head captures "a" at the first hyphen and Rest absorbs everything after it, separators included.

It only constrains call sites whose argument still carries a literal or template literal type. A value typed plain string is rejected until someone asserts it, and nothing is verified at runtime because the type is erased.

Uppercase, Lowercase, Capitalize and Uncapitalize. Each transforms a string literal type, and they are declared as intrinsic in lib.es5.d.ts, meaning the compiler implements them natively because the type system has no character-level string operation.

Use a recursive type alias: a JSON value is a string, number, boolean, null, an array of JSON values, or an object whose values are JSON values. The self-reference is legal because TypeScript resolves it lazily instead of expanding it eagerly.

The extends object test also matches arrays, Dates, Maps and functions, so the helper recurses into them: array elements gain undefined, a Date becomes an object of optional methods, and a function loses its call signature. Fix it by bailing out on those shapes before the object branch.

Recurse over the keys, emitting each key and, for object-valued keys, that key joined to the child's paths with a dot. Arrays leak Array's own member names into the union, and a self-referencing type recurses forever until the compiler reports an excessive-depth error.

The checker hit its cap on nested type instantiations while expanding a recursive type and gave up rather than hang. Fix it by adding or correcting a base case, rewriting the recursion with an accumulator so the recursive call sits in tail position, or capping depth with a counter.

The checker does real work per generic instantiation and per assignability comparison, and the editor's TypeScript server repeats it while you type. Large unions, deeply nested conditionals, long intersection chains and inferred-instead-of-annotated return types are the usual expensive shapes.

No — TypeScript erases types, so even elaborate helpers emit no JavaScript and cost nothing at run time. Their price is paid at check time: slower tsc runs, laggy editor completions, and error messages teammates struggle to read.

The checker reports the failure with both sides fully expanded at the outermost place it noticed, so a computed type prints as its whole structure and gets truncated. Control it by naming intermediate aliases, constraining parameters, testing types in isolation, and using --noErrorTruncation when you need the full text.

Measure before rewriting anything. Run tsc with --extendedDiagnostics to see whether check time and instantiation counts dominate, then --generateTrace into a directory and analyse the trace with @typescript/analyze-trace to get the specific files and positions that are slow.

Judge each clever type by guarantee per unit of cost: build and editor latency, plus how many teammates can maintain it. Anything about data entering the program from outside cannot be guaranteed by types at all and belongs in a runtime validator, with the static types derived from that schema.