How do conditional types work, and what is distribution?

T extends U ? X : Y is a type-level if: it resolves to X when T is assignable to U, otherwise Y. While T or U still contains an unresolved type parameter the conditional is deferred: it stays as written until the alias is instantiated. That is why a function returning T extends string ? "s" : "n" cannot return a plain "s" from its body: the compiler cannot know which branch applies.

Distribution. If the checked type is a naked type parameter (just T, not T[], keyof T or [T]), the conditional is distributive. Instantiated with a union, it is applied to each member and the results are unioned:

• IsString<string | number> is boolean, because it is true | false.
• never is the empty union, so a distributive conditional over never yields never, not either branch.
• any evaluates to the union of both branches.

Distribution is usually what you want: Exclude<T, U> and Extract<T, U> rely on it to filter unions.

Turning it off. Wrap both sides in a tuple: [T] extends [U]. The union is now compared as one type. This is also the reliable way to detect never ([T] extends [never]).

Constraints in the true branch. Inside X, T is treated as also being U, and infer can name parts of the matched type (see the infer question).

Distribution depends only on the written form of the check type. It happens at instantiation, so a non-generic string | number extends string ? 1 : 2 is just 2, and the same check through a naked T gives a union.

Interview-level summary: conditional types are lazy, distribute over naked type parameters, collapse on never, and are opted out with [T] extends [U].

// TypeScript 7.0.2 and 5.9.3, --strict
type IsString<T> = T extends string ? true : false;
type A = IsString<"a">; // true
type B = IsString<string | number>; // boolean
type C = IsString<never>; // never
type D = IsString<any>; // boolean

type Whole<T> = [T] extends [string] ? true : false;
type E = Whole<string | number>; // false
type F = Whole<never>; // true

type ToArray<T> = T extends unknown ? T[] : never;
type NoDist<T> = [T] extends [unknown] ? T[] : never;
type G = ToArray<string | number>; // string[] | number[]
type H = NoDist<string | number>; // (string | number)[]

type Literal = string | number extends string ? 1 : 2; // 2: not generic, no distribution

function label<T extends string | number>(x: T): T extends string ? "s" : "n" {
  return typeof x === "string" ? "s" : "n";
}
// Error TS2322: Type '"s"' is not assignable to type 'T extends string ? "s" : "n"'.
// Error TS2322: Type '"n"' is not assignable to type 'T extends string ? "s" : "n"'.

• Expecting IsX<never> to return false. A distributive conditional over never is never. Use [T] extends [never] to test for it.
• Writing T[] extends U[] or keyof T extends ... and expecting distribution. Only a bare T distributes.
• Returning a literal from a function whose return type is a deferred conditional. Use an overload, or a single assertion at the boundary, and keep the conditional in the public signature.
• Using [T] extends [U] to "fix" a union and then being surprised that Whole<never> is true: never is assignable to everything.