Conditional Types & infer

Also Known As

TL;DR

Explanation

Conditional types: T extends Condition ? TrueType : FalseType. Distributive conditional types: when T is a union, the condition distributes over each member. The infer keyword captures a type variable within the extends clause: T extends Promise<infer U> ? U : never extracts the resolved type of a Promise. Built-in TypeScript utilities using conditional types: ReturnType<T>, Parameters<T>, InstanceType<T>, Awaited<T>. Essential for building type utilities that work with generic type shapes.

Common Misconception

Why It Matters

Common Mistakes

• Forgetting distributivity — T extends string ? true : false where T = string | number gives boolean, not true.
• Infinite type recursion — conditional types can recurse; TypeScript limits depth.
• Using conditional types where generics or overloads are cleaner.
• Not using infer when extracting nested types — manual type indexing is error-prone.

Code Examples

// Manual return type extraction — not generic:
type StringFuncReturn = string;
type NumberFuncReturn = number;
// Need separate type for every function signature

// Conditional type with infer — works for any function:
type ReturnType<T extends (...args: any) => any> =
    T extends (...args: any) => infer R ? R : never;

// Unwrap Promise:
type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;

// Extract array element type:
type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<string[]>;  // string
type B = Awaited<Promise<number>>; // number

// Distributive:
type NonNullable<T> = T extends null | undefined ? never : T;
type C = NonNullable<string | null | undefined>; // string

References

• ↗ https://www.typescriptlang.org/docs/handbook/2/conditional-types.html

Tags

Related Terms