Type Predicates (x is T)

## Why a predicate exists at all TypeScript's checker narrows types by reading the *code* of a condition: it recognises shapes like a `typeof` comparison, an `instanceof` test, or a discriminant equality check, and refines the variable inside the branch. A hand-written helper hides that check behind a function call, and calls are opaque to this analysis — the checker does not inline the body to see what it proved. Only the helper's **signature** crosses the call boundary. A type predicate is the mechanism for putting the narrowing *into* the signature so it survives the call. ## Reading the signature ```ts function isString(value: unknown): value is string { return typeof value === "string"; } ``` The return-type position holds `parameterName is Type` instead of `boolean`. The name on the left must be a parameter of that same function; the type on the right is what the compiler will assume about the corresponding argument when the call evaluates to `true`. The body still has to return a boolean expression — a predicate function is an ordinary boolean function with a richer declared return type. ## What the call site does ```ts function describe(input: unknown) { if (isString(input)) { return input.toUpperCase(); // input: string } return String(input); // input: unknown } ``` Narrowing lands on the *argument expression*, not on the parameter. It works when the argument is a reference the checker can track: a variable, a `const`, or a property path such as `payload.name` — `if (isString(payload.name)) payload.name.trim()` compiles. It does not work when you pass a fresh expression like `isString(makeValue())`, because there is no reference left to narrow, and it resets if you reassign the variable afterwards. ## Both branches, not just the true one In the true branch the compiler keeps the parts of the declared type compatible with the asserted type. If the declared type is `unknown` or `any`, you simply get the asserted type; if it is a union, you get the members assignable to it. The false branch does the opposite where it can: it *subtracts*. ```ts declare function isString(v: string | number): v is string; function f(v: string | number) { if (isString(v)) { v; // string } else { v; // number — string was removed from the union } } ``` Subtraction only happens when the declared type is a union containing something to remove. Starting from `unknown`, the else branch is still `unknown`, because "not a string" is not a type TypeScript can name. Candidates often expect `never` there — that is wrong. ## Nothing of this exists at runtime Types are erased. The emitted JavaScript for `isString` is the same function with the annotations stripped: ```js function isString(value) { return typeof value === "string"; } ``` That has two consequences worth saying out loud in an interview. First, a predicate costs nothing: it is not a cast, not a conversion, not a reflective check the compiler bolts on. Second, the annotation is a *promise the compiler takes at face value* — the type layer trusts what the signature claims about the boolean the body returns. ## Where they earn their keep Any place a value arrives untyped and you need to prove its shape once and use it many times: the result of `JSON.parse` (typed `any`), a `catch` variable typed `unknown` under `useUnknownInCatchVariables`, a message from a worker or socket, or a wide union you want to split. Writing `as string` at each use site would type-assert without checking and would have to be repeated; a predicate performs the real runtime check in one place and hands the narrowing to every caller. ## Habits that keep them readable Name them `isX` so the call site reads like a condition. Keep the body to a single boolean expression. Declare the parameter as wide as callers actually need — `unknown` for values from outside the program, the union type when you are splitting a known union — since the asserted type must be compatible with the parameter's declared type.