In TypeScript, `type IsString<T> = T extends string ? true : false` gives `boolean` for `IsString<string | number>`. Explain that result and how you would make the check apply to the whole union instead.

## Reading the result honestly When a type-level predicate returns `boolean` instead of `true` or `false`, the instinct is to assume the check broke. It didn't. `boolean` in TypeScript *is* the union `true | false` — the two boolean literal types unioned — and the checker collapses `true | false` back to the display name `boolean` whenever it sees it. So a `boolean` result from a predicate means the predicate produced **both** answers. Both answers appear because the conditional distributed: ```ts type IsString<T> = T extends string ? true : false; type R = IsString<string | number>; // IsString<string> | IsString<number> // true | false // boolean ``` Distribution kicks in whenever the checked type — the part written before `extends` — is a **naked type parameter** and the argument supplied for it is a union. TypeScript substitutes each member in turn, evaluates the conditional once per member, and unions the results. ## The opt-out: one-element tuples The fix is to make the checked type not be a naked parameter. Any wrapper technically works, but the idiomatic one is a one-element tuple, because it wraps the type without changing the assignability relationship you actually care about: ```ts type IsStringWhole<T> = [T] extends [string] ? true : false; type S1 = IsStringWhole<string>; // true type S2 = IsStringWhole<string | number>; // false type S3 = IsStringWhole<'a' | 'b'>; // true — both members are strings ``` Three details matter here. **Both sides get wrapped.** `T extends [string]` is a different question entirely — it asks whether `T` is a tuple. The tuple is a wrapper for the comparison, not part of the thing being compared, so it goes on both sides. **The answer is now about the union as a whole.** `IsStringWhole<'a' | 'b'>` is still `true`, because every member of that union is assignable to `string`, so the tuple `['a' | 'b']` is assignable to `[string]`. Blocking distribution does not mean "only single types pass"; it means one assignability question is asked about the entire type. **Parentheses do nothing.** `(T) extends (string)` is the same type as `T extends string`; parentheses are grouping syntax with no effect on nakedness. Only an actual wrapping construct — a tuple, an array, an object type — changes the position. ## The same trap in the other direction Because `boolean` is a union, it is also *split* when it goes in: ```ts type YesNo<T> = T extends true ? 'yes' : 'no'; type B1 = YesNo<true>; // 'yes' type B2 = YesNo<false>; // 'no' type B3 = YesNo<boolean>; // 'yes' | 'no' ``` This bites when a flag type is `boolean` rather than a specific literal — for example a helper that is supposed to pick a strict or loose result shape based on an options flag, which silently returns the union of both shapes for any caller who did not pass a literal. Two common repairs: block distribution with `[T] extends [true]`, or make the call site produce a literal type (an `as const` object, or a `T extends boolean` parameter inferred from a literal argument). ## Building an exact-equality check Once you can block distribution, an "is `T` exactly `U`" predicate follows from mutual assignability, still non-distributively: ```ts type IsExactly<T, U> = [T] extends [U] ? ([U] extends [T] ? true : false) : false; type E1 = IsExactly<string, string>; // true type E2 = IsExactly<'a', string>; // false type E3 = IsExactly<string | number, string>;// false ``` That is enough for most day-to-day use. It is deliberately not a perfect equality test — `any` in particular is assignable in both directions to everything, so it slips through — which is why library-grade equality helpers use more elaborate tricks. Knowing the limitation is more valuable in an interview than reciting the trick. ## Where this shows up in real code The usual sighting is a helper that behaves correctly in the tests, where it is always instantiated with a single concrete type, and then produces a uselessly wide type the moment a caller passes a union. A `boolean` where you expected `false`, a `'yes' | 'no'` where you expected one branch, a result type carrying properties from members that should have been excluded — those are all one diagnosis: the conditional distributed and you wanted it to judge the whole type. ## Erasure None of this survives compilation. `IsString` and `IsStringWhole` emit no JavaScript, and the tuple in `[T] extends [string]` never allocates an array — it exists only as a comparison wrapper inside the checker. The choice between distributing and not is purely about what type the compiler reports.