TypeScript Discriminated Unions: Tagged Unions Explained

A discriminated union (also called a tagged union) is a union of object types that all have one property in common, the tag, with a different literal value in each member. Checking the tag tells TypeScript which member you have, and the other properties of that member become available.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rect"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2; // shape is the circle member here
    case "rect":
      return shape.width * shape.height;
    case "triangle":
      return (shape.base * shape.height) / 2;
  }
}

const shapes: Shape[] = [
  { kind: "circle", radius: 1 },
  { kind: "rect", width: 2, height: 3 },
  { kind: "triangle", base: 4, height: 5 },
];

for (const s of shapes) console.log(s.kind, area(s).toFixed(2));
// circle 3.14
// rect 6.00
// triangle 10.00

Inside case "circle", reading shape.width would be a compile error, because the circle member has no width. The tag is ordinary data: at runtime it is just a string property, and the switch is plain JavaScript.

What Makes a Union Discriminated

Narrowing on the tag works when three conditions hold:

1. Every member is an object type.
2. Every member has the same property name (the discriminant). The name is up to you: kind, type, status and tag are common.
3. In each member, that property has a literal type: a string, number or boolean literal, or null/undefined.

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

type ApiResponse =
  | { ok: true; data: string }    // boolean literal tags
  | { ok: false; error: string };

type Message =
  | { version: 1; text: string }  // number literal tags
  | { version: 2; text: string; lang: string };

If one member declares the tag as plain string instead of a literal, comparing the tag no longer narrows the union, and member-specific properties stay out of reach (TS2339).

Narrowing on the Tag

Any check TypeScript understands on the tag narrows the object: switch, if/else, === and !==, even a destructured tag as long as it is a const:

function describe(e: UiEvent): string {
  if (e.type === "click") return `click at ${e.x},${e.y}`;

  const { type } = e;        // destructured tags narrow too
  if (type === "keypress") return `key ${e.key}`;

  return `scroll by ${e.delta}`; // only "scroll" is left
}

Checking for a property with "radius" in shape also narrows, but comparing a tag is clearer to read and makes exhaustive checking possible.

Exhaustive Checks

The biggest benefit of the pattern shows up when the union grows. With an explicit return type and no default, TypeScript knows the switch must cover every tag, so a new member without a case is a compile error:

// This does not compile: the "square" case is missing
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rect"; width: number; height: number }
  | { kind: "square"; size: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rect":
      return shape.width * shape.height;
  }
}

console.log(area({ kind: "square", size: 2 }));

index.ts(7,30): error TS2366: Function lacks ending return statement and return type does not include 'undefined'.

That message does not say which case is missing. The assertNever helper does, and it also throws at runtime if data from outside (JSON, an older client) carries a tag the types say cannot exist:

type RequestState<T> =
  | { status: "idle" }
  | { status: "loading"; startedAt: number }
  | { status: "success"; data: T }
  | { status: "error"; error: string; retryable: boolean };

function assertNever(value: never): never {
  throw new Error(`Unexpected state: ${JSON.stringify(value)}`);
}

function render(state: RequestState<string[]>): string {
  switch (state.status) {
    case "idle":
      return "Press load";
    case "loading":
      return `Loading since t=${state.startedAt}`;
    case "success":
      return `Loaded ${state.data.length} items: ${state.data.join(", ")}`;
    case "error":
      return `Failed: ${state.error}${state.retryable ? " (retry?)" : ""}`;
    default:
      return assertNever(state); // state is never here
  }
}

const states: RequestState<string[]>[] = [
  { status: "idle" },
  { status: "loading", startedAt: 1200 },
  { status: "success", data: ["a", "b"] },
  { status: "error", error: "timeout", retryable: true },
];

for (const s of states) console.log(render(s));
// Press load
// Loading since t=1200
// Loaded 2 items: a, b
// Failed: timeout (retry?)

Add a fifth status without a case and the assertNever(state) line reports Argument of type '{ status: "..."; ... }' is not assignable to parameter of type 'never', naming the member. More on this in the never page.

Making Impossible States Impossible

RequestState above replaces a common, weaker shape:

// Every combination is allowed, including nonsense
type LooseState<T> = {
  loading: boolean;
  data?: T;
  error?: string;
};

const nonsense: LooseState<string[]> = { loading: true, data: ["a"], error: "timeout" };

With optional fields, "loading with data and an error" type-checks, and every reader has to guess which combinations can really happen. With the discriminated union, data exists only in the success state and error only in error, so code that reads state.data must first prove it is in the success state. The type itself documents the valid states.

Modeling Results: Success or Failure

A boolean tag is enough for "it worked or it did not". This Result type is a common alternative to throwing exceptions for expected failures such as invalid input:

type Result<T, E = string> =
  | { ok: true; value: T }
  | { ok: false; error: E };

function parsePort(text: string): Result<number> {
  const n = Number(text);
  if (!Number.isInteger(n)) return { ok: false, error: `"${text}" is not a whole number` };
  if (n < 1 || n > 65535) return { ok: false, error: `${n} is out of range` };
  return { ok: true, value: n };
}

for (const input of ["8080", "http", "70000"]) {
  const result = parsePort(input);
  if (result.ok) {
    console.log("port", result.value);   // result.value exists only here
  } else {
    console.log("error:", result.error); // result.error exists only here
  }
}
// port 8080
// error: "http" is not a whole number
// error: 70000 is out of range

The caller cannot read result.value without checking result.ok first, which is exactly the check that is easy to forget with exceptions or with null returns.

State Machines and Reducers

Two discriminated unions, one for states and one for actions, describe a state machine. A reducer switches on the action and returns the next state; the compiler checks that each returned object is a valid state:

type State =
  | { name: "idle" }
  | { name: "playing"; track: string; position: number }
  | { name: "paused"; track: string; position: number };

type Action =
  | { type: "play"; track: string }
  | { type: "pause" }
  | { type: "resume" }
  | { type: "stop" };

function reduce(state: State, action: Action): State {
  switch (action.type) {
    case "play":
      return { name: "playing", track: action.track, position: 0 };
    case "pause":
      return state.name === "playing" ? { ...state, name: "paused" } : state;
    case "resume":
      return state.name === "paused" ? { ...state, name: "playing" } : state;
    case "stop":
      return { name: "idle" };
  }
}

const actions: Action[] = [{ type: "play", track: "Intro" }, { type: "pause" }, { type: "resume" }, { type: "stop" }];

let state: State = { name: "idle" };
for (const a of actions) {
  state = reduce(state, a);
  console.log(a.type.padEnd(6), "->", state.name);
}
// play   -> playing
// pause  -> paused
// resume -> playing
// stop   -> idle

{ ...state, name: "paused" } compiles only because state was narrowed to the playing member first, so the copy carries track and position. Returning { name: "paused" } alone would be an error: a paused state needs a track. This is the same shape Redux reducers and useReducer in React use.

The Widening Trap

The tag must stay a literal type. An object built into a variable with no annotation has its tag widened to string, and then it matches no member:

type Shape = { kind: "circle"; radius: number } | { kind: "rect"; width: number; height: number };
declare function area(shape: Shape): number;

const c = { kind: "circle", radius: 2 }; // kind: string
area(c);
// error TS2345: Argument of type '{ kind: string; radius: number; }' is not assignable to parameter of type 'Shape'.

const ok1: Shape = { kind: "circle", radius: 2 };        // annotate the variable
const ok2 = { kind: "circle", radius: 2 } as const;      // or keep the literal with as const
area({ kind: "circle", radius: 2 });                     // or build it where Shape is expected

The underlying rule, that mutable properties widen, is explained on the literal types page.