Conditional Types

## The shape A conditional type has exactly one form: ```ts T extends U ? X : Y ``` Read it as a ternary that lives in the type system. `T` is the *checked* type, `U` is the type it is checked against, and `X` and `Y` are the two possible results. All four positions hold types — you cannot put a value, a runtime expression, or a `typeof x` on a variable there. Everything happens while the compiler is running; the emitted JavaScript contains no trace of it. The usual way to meet one is inside a generic type alias, because that is what makes the construct useful: ```ts type IsString<T> = T extends string ? 'yes' : 'no'; ``` `IsString` is now a type-level function: give it a type argument, get a type back. ## The test is assignability The most common misreading is treating `extends` here as the class keyword — "is T a subclass of string". It is not. In a conditional type, `A extends B` asks a single question: **is a value of type A usable everywhere a value of type B is expected?** That is the ordinary assignability relation the checker uses everywhere else, applied at the type level. So the direction matters. The *more specific* type goes on the left: ```ts type A = IsString<'abc'>; // 'yes' — the literal type 'abc' is assignable to string type B = IsString<string>; // 'yes' — a type is assignable to itself type C = IsString<number>; // 'no' ``` `'abc'` is a *literal type*: the type whose only inhabitant is that one string. Every string literal type is assignable to `string`, which is why `IsString<'abc'>` takes the true branch. ## When it evaluates A conditional type is resolved when the compiler knows what the checked type actually is. Writing the alias declares the rule; writing `IsString<'abc'>` *instantiates* it, and at that point the checker performs the assignability test and replaces the whole conditional with one branch. Hover over `A` in an editor and you see `'yes'` — the conditional has already collapsed. This is why the construct composes: the result is an ordinary type and can be used anywhere a type can be used. ```ts const answer: IsString<'abc'> = 'yes'; // const wrong: IsString<'abc'> = 'no'; // Error: 'no' is not assignable to 'yes' ``` When the checked type is still an unresolved type parameter — inside a generic function body, for instance — the compiler cannot pick a branch yet and keeps the conditional around unevaluated. That deferred state has consequences of its own, and it is worth knowing that it exists. ## Both branches are types A frequent beginner slip is expecting the branches to be values, or expecting them to be the same kind of thing. They need not match at all: ```ts type Result<T> = T extends string ? string[] : never; type Flag<T> = T extends string ? true : false; ``` `true` and `false` here are the boolean *literal types*, not runtime booleans. `never` is the type with no values, and it is a common choice for a branch meaning "this case does not apply". ## Nothing is emitted This follows from the rule that organises all of TypeScript: types are erased. Compile a file whose only content is a conditional type alias and the output JavaScript is empty. There is no runtime cost, no reflection, no way to ask at run time which branch was taken, and no way to make the decision depend on a runtime value. If you need a decision at run time, you write ordinary JavaScript — the conditional type only describes what the compiler should believe. ## Where it earns its place Conditional types are how a type describes a rule instead of a fixed shape: "the return type depends on what you passed in", "this property only exists when that flag is set". Used sparingly they make an API's types honest. Used heavily they make error messages long and hard to read, because the compiler prints the unresolved conditional rather than a friendly name. ## Common mistakes to avoid - Reading `T extends string` as a declaration that constrains `T`. In the conditional position it is a *question*, not a restriction; a conditional type accepts whatever it is given and answers accordingly. - Expecting a runtime check. Nothing is checked at run time. - Writing the wide type on the left and the narrow one on the right, then being surprised the test fails.