TypeScript Exclude, Extract and NonNullable Explained

Exclude<T, U> removes members from a union type, Extract<T, U> keeps only the matching members, and NonNullable<T> removes null and undefined. All three filter unions; they do not touch object properties.

type Status = "draft" | "review" | "published" | "archived";

type Visible = Exclude<Status, "draft" | "archived">; // "review" | "published"
type Editable = Extract<Status, "draft" | "review">;   // "draft" | "review"

const shown: Visible[] = ["review", "published"];
const editing: Editable = "draft";
console.log(shown, editing); // [ 'review', 'published' ] draft

// @ts-expect-error: Type '"draft"' is not assignable to type 'Visible'.
const bad: Visible = "draft";

Like every utility type, these exist only at compile time. The last line is rejected by the compiler; the JavaScript that runs has no idea what Visible is.

Exclude, Extract and NonNullable at a Glance

"Assignable to U" is the key phrase. U does not have to be a list of exact members; it can be a wider type that several members fit:

type Input = string | number | boolean | (() => void) | null;

type Primitive = Exclude<Input, (() => void) | null>; // string | number | boolean
type Callable = Extract<Input, (...args: never[]) => unknown>; // () => void
type Present = NonNullable<Input>; // string | number | boolean | (() => void)

const values: Primitive[] = ["a", 1, true];
const run: Callable = () => console.log("called");
const p: Present = 42;

run();
console.log(values, p); // [ 'a', 1, true ] 42

Picking Union Members by Shape

On a discriminated union, Extract with a partial shape pulls out the variants that have it. This is the usual way to name one variant of a union you did not write yourself:

type AppEvent =
    | { type: "click"; x: number; y: number }
    | { type: "key"; key: string }
    | { type: "scroll"; delta: number };

type ClickEvent = Extract<AppEvent, { type: "click" }>;
type NonClickEvent = Exclude<AppEvent, { type: "click" }>;

function handleClick(e: ClickEvent): string {
    return `click at ${e.x},${e.y}`; // x and y are available
}

function describe(e: NonClickEvent): string {
    return e.type === "key" ? `key ${e.key}` : `scroll ${e.delta}`;
}

console.log(handleClick({ type: "click", x: 10, y: 20 })); // click at 10,20
console.log(describe({ type: "key", key: "Enter" }));      // key Enter

The shape { type: "click" } is a supertype of the click variant only, so that is the one Extract keeps. A shape that matches several variants (say { x: number } if two had it) keeps all of them.

NonNullable

NonNullable<T> is the type version of a !== null && !== undefined check. It shows up when you derive a type from something optional:

type User = { name: string; manager?: { name: string } | null };

type Manager = NonNullable<User["manager"]>; // { name: string }

function managerName(m: Manager): string {
    return m.name; // no null check needed
}

const u: User = { name: "Ada", manager: { name: "Grace" } };
if (u.manager) {
    console.log(managerName(u.manager)); // Grace
}

// Filtering null and undefined out of an array, with a matching type:
const raw: Array<string | null | undefined> = ["a", null, "b", undefined];
const clean = raw.filter((s): s is NonNullable<typeof s> => s != null);
console.log(clean); // [ 'a', 'b' ]

User["manager"] is { name: string } | null | undefined (the ? adds undefined), and NonNullable strips both. Since TypeScript 5.5 the compiler also infers that predicate by itself, so raw.filter((s) => s != null) is already typed string[]; the explicit s is NonNullable<typeof s> keeps the intent visible and works in older versions. Its definition is type NonNullable<T> = T & {}: the empty object type {} accepts every value except null and undefined, so intersecting with it removes exactly those.

How They Are Built

Exclude and Extract are one-line conditional types in the standard library:

type Exclude<T, U> = T extends U ? never : T;
type Extract<T, U> = T extends U ? T : never;

When T is a union, a conditional type is applied to each member separately (it distributes), and never members vanish from the result. So Exclude<"a" | "b", "a"> becomes ("a" extends "a" ? never : "a") | ("b" extends "a" ? never : "b"), which is never | "b", which is "b". The conditional types page covers distribution in detail.

Exclude vs Omit, Extract vs Pick

The names are easy to mix up because both pairs "remove" or "keep" something. The difference is what they operate on:

Using Exclude on an object type is a common slip, and it fails silently:

type Account = { id: number; email: string; password: string };

type Wrong = Exclude<Account, "password">; // still Account: not a union of "password"
type Right = Omit<Account, "password">;    // { id: number; email: string }

const safe: Right = { id: 1, email: "ada@example.com" };
const oops: Wrong = { id: 1, email: "ada@example.com", password: "hunter2" };
console.log(Object.keys(safe), Object.keys(oops));
// [ 'id', 'email' ] [ 'id', 'email', 'password' ]

Account is not assignable to "password", so Exclude keeps it whole. Omit itself is built from Exclude applied to the keys: Omit<T, K> is Pick<T, Exclude<keyof T, K>>. See Omit for more.

A Stricter Exclude

Exclude's second parameter accepts any type, so a typo removes nothing and raises no error. Adding a constraint makes the compiler check that what you exclude is really in the union:

// This does not compile: "drafft" is not a Status.
type Status = "draft" | "published" | "archived";

type StrictExclude<T, U extends T> = Exclude<T, U>;

type Loose = Exclude<Status, "drafft">;        // silently Status, unchanged
type Strict = StrictExclude<Status, "drafft">; // error

const s: Strict = "published";
console.log(s);

index.ts(7,37): error TS2344: Type '"drafft"' does not satisfy the constraint 'Status'.

Fix the spelling and it compiles, with Strict equal to "published" | "archived". The same trick works for Extract and for a strict Omit (K extends keyof T).