Write the one-line definitions of TypeScript's built-in `Exclude<T, U>` and `Extract<T, U>` yourself, and explain why they filter a union member by member instead of testing the union as a whole.

## The two definitions Both types are one line each in TypeScript's standard library: ```ts type Exclude<T, U> = T extends U ? never : T; type Extract<T, U> = T extends U ? T : never; ``` Read them literally: "if `T` is assignable to `U`, produce `never`, otherwise produce `T`" and the reverse. They differ only in which branch keeps the type and which throws it away, so if you can write one you can write the other by swapping the branches. ## What `extends` means here Inside a conditional type, `A extends B` is not class inheritance. It is the assignability question: *can a value of type A be used where a B is expected?* `'draft' extends string` is true; `string extends 'draft'` is false; `() => void extends Function` is true. Understanding that the test is assignability, not equality, explains most of the surprising results — `Exclude<string | number, unknown>` is `never`, because everything is assignable to `unknown`. ## Why the filter runs per member When the type being tested is a bare type parameter — `T` written by itself immediately to the left of `extends`, not wrapped in anything — and the type substituted for it is a union, the checker applies the conditional once per member and unions the results. So evaluating `Exclude<'a' | 'b' | 'c', 'a'>` is really three evaluations: ``` 'a' extends 'a' ? never : 'a' -> never 'b' extends 'a' ? never : 'b' -> 'b' 'c' extends 'a' ? never : 'c' -> 'c' ``` unioned back together as `never | 'b' | 'c'`. Because `never` is the empty type, a union containing it reduces to the other members, so the final answer is `'b' | 'c'`. That reduction is why `never` is the right "delete me" marker: any other choice would leave debris in the result. If the conditional tested the union as a whole instead, `'a' | 'b' | 'c' extends 'a'` would simply be false and you would get the entire union back unchanged — which is exactly what happens to the naive first attempt candidates often write. Filtering *requires* the per-member evaluation. ## Writing your own variants Once you have the shape, the useful variants come cheaply: ```ts type MyExclude<T, U> = T extends U ? never : T; type MyExtract<T, U> = T extends U ? T : never; type MyNonNullable<T> = T extends null | undefined ? never : T; type Falsy<T> = Extract<T, '' | 0 | false | null | undefined>; ``` `Falsy` shows the composition style: you rarely need a new conditional, you just pick a different `U`. Note that `MyNonNullable` written as a conditional is how the standard library used to define it; in the TypeScript 5.x line the library instead uses the intersection `type NonNullable<T> = T & {}`, where `{}` means "any value that is not `null` or `undefined`". Both give the same answer for concrete unions. ## The relationship between the two `Exclude` and `Extract` partition the union: for any `T` and `U`, every member of `T` ends up in exactly one of `Exclude<T, U>` and `Extract<T, U>`. That duality is worth saying out loud in an interview, and it is also a practical debugging tool — if `Extract<T, U>` is `never`, then `Exclude<T, U>` is the whole of `T`, which tells you your `U` matched nothing. ## Common mistakes when writing them cold - Swapping the branches, so `Exclude` keeps what it should drop. Sanity-check with a two-member union before moving on. - Returning `undefined` or `void` instead of `never` in the discard branch. Neither disappears from a union, so `Exclude<'a' | 'b', 'a'>` would come back as `undefined | 'b'`. - Wrapping the parameter — writing `[T] extends [U] ? ... : ...` — which deliberately turns the per-member behaviour off and makes the whole union get tested at once. That is a real technique for other purposes, but it breaks a filter. - Adding a constraint like `U extends T` and assuming that is what the library does. It is not; the built-ins leave `U` completely unconstrained. ## Why interviewers ask this one It is the cheapest possible probe of conditional types: two lines, no cleverness, and a candidate either knows the shape or does not. It also opens the door to the follow-up that actually separates people — what `never` does inside a union, and what happens when the filter removes everything.