What are conditional and mapped types?

Question

Accepted Answer

These are TypeScript's **type-level programming** tools — they compute new types from existing ones. ## Mapped types — transform each property A mapped type iterates over the keys of a type and transforms each: ```ts type ReadonlyAll = { readonly [K in keyof T]: T[K] }; type Optional = { [K in keyof T]?: T[K] }; interface User { id: number; name: string; } type RO = ReadonlyAll; // { readonly id: number; readonly name: string } ``` `[K in keyof T]` loops over each key `K`; `T[K]` is that key's value type. This is how `Partial`, `Readonly`, and `Required` are implemented. You can also remap keys and add modifiers (`-readonly`, `-?` remove them). ## Conditional types — branch on a condition ```ts type IsString = T extends string ? "yes" : "no"; type A = IsString; // "yes" type B = IsString; // "no" ``` `T extends U ? X : Y` is a type-level if/else. With `infer` you can *extract* types inside the condition: ```ts type ElementOf = T extends (infer U)[] ? U : never; type E = ElementOf; // string ``` ## Combining them — a real example ```ts // Make only the function-valued properties optional type PartialMethods = { [K in keyof T]: T[K] extends Function ? T[K] | undefined : T[K]; }; ``` Mapped types also **distribute** over unions in conditionals, enabling powerful transforms. ## Why it matters Mapped and conditional types let libraries express precise type relationships — they implement the utility types, power form/validation libraries, ORM query builders, and API clients that infer response shapes. They're advanced, but understanding them explains *how* TypeScript's type system can be so expressive, and lets you build reusable type transforms instead of hand-writing variants.