In a TypeScript conditional type, what does the `infer` keyword do, where may the variable it declares be used, and how would you write an `ElementType<T>` that pulls the element type out of an array type?

## The problem `infer` solves A conditional type `T extends U ? X : Y` asks a yes/no question: is `T` assignable to `U`? On its own that only picks a branch. Usually what you want is a *piece* of the type you just matched: the element type of an array, the value a promise resolves to, the type a callback receives. `infer` is the mechanism for that. It declares a temporary type variable at a position inside the pattern, and if the match succeeds the compiler fills that variable in with whatever it found there. Think of it as destructuring for types. In JavaScript you write `const [first] = arr` to name a piece of a value. In TypeScript's type layer you write `T extends [infer First, ...unknown[]] ? First : never` to name a piece of a *type*. ## Writing the canonical extractor ```ts type ElementType<T> = T extends readonly (infer U)[] ? U : never; type A = ElementType<string[]>; // string type B = ElementType<number[][]>; // number[] type C = ElementType<string>; // never ``` The parentheses in `(infer U)[]` matter: they bind the inference to the *element* slot of an array type. Writing `readonly` in the pattern is a small but useful trick — a mutable `string[]` is assignable to `readonly string[]`, so the readonly form matches both mutable and readonly arrays, while `T extends (infer U)[]` alone rejects a `readonly string[]` input. `Array<infer U>` is an equivalent spelling of the same pattern. ## The two scope rules **`infer` only lives in an `extends` clause of a conditional type.** You cannot write `type Bad<T> = infer U;` or put `infer` on the left of `extends`. The compiler rejects it with a message saying `infer` declarations are only permitted in the extends clause of a conditional type. It is not a general "give me a fresh type variable" keyword; it is part of the matching syntax. **The variable exists only in the true branch.** `type Bad<T> = T extends (infer U)[] ? number : U;` fails with a cannot-find-name error on the `U` in the false branch. That is not an arbitrary restriction: the false branch is reached precisely when the pattern did not match, so there is nothing for `U` to be. ## Choosing the false branch The false branch is a design decision, and interviewers listen for it. ```ts type Unwrap<T> = T extends Promise<infer U> ? U : T; // pass-through type StrictUnwrap<T> = T extends Promise<infer U> ? U : never; // fail loudly ``` `T` as the fallback makes the helper idempotent and forgiving — `Unwrap<string>` is `string`. `never` makes a mismatch visible: the result becomes uninhabitable, and downstream code that tries to use it usually errors. A third option is a sentinel object type, which produces friendlier errors than a bare `never`. Returning `unknown` is the least useful choice, because it silently swallows the failure and forces callers to narrow. ## Multiple `infer` variables One `extends` clause may declare several, with different names: ```ts type Split<T> = T extends { data: infer D; error: infer E } ? [D, E] : never; type R = Split<{ data: string; error: Error }>; // [string, Error] ``` Each name is bound independently. Reusing the *same* name at two positions is legal too, but it changes the semantics — the compiler then has to combine several candidates into one type, which is a separate topic. ## Nothing here exists at runtime This is the point the whole type layer sits on. `ElementType` is not a function; it produces no JavaScript. There is no runtime array to inspect, no check performed, no cost paid. If a candidate says "infer looks at the value and works out its type", they have confused the type layer with reflection. The compiler is matching *declared* types against a pattern during checking, then erasing the entire apparatus. A corollary: because the matching is purely structural and compile-time, `infer` can only recover what the type system was told. If a value arrives as `any` or is asserted with `as`, the extraction faithfully propagates whatever fiction was declared. ## What interviewers are really testing They want to see you write a small extractor on a whiteboard without hesitating: name the conditional, put `infer` in the right slot, pick a sensible false branch, and say out loud that the variable is true-branch-only. Getting `ElementType` and a one-level promise unwrapper right, and explaining why the false branch matters, covers almost everything this question is asked to reveal.