typescript 41 lines · 8 steps

Modeling request state with discriminated unions

A discriminated union makes each request phase carry exactly the data it needs, and the compiler enforces every case.

Explained by highlit

Intermediate discriminated-unions exhaustiveness-checking state-machine type-narrowing generics

1type RequestState<T, E = string> =
| { status: "idle" }
| { status: "loading" }
| { status: "success"; data: T; fetchedAt: number }
| { status: "error"; error: E; retryable: boolean };
6 
7function reducer<T>(
state: RequestState<T>,
action:
  | { type: "fetch" }
  | { type: "resolve"; data: T }
  | { type: "reject"; error: string; retryable: boolean }
13): RequestState<T> {
switch (action.type) {
  case "fetch":
    return { status: "loading" };
  case "resolve":
    return { status: "success", data: action.data, fetchedAt: Date.now() };
  case "reject":
    return { status: "error", error: action.error, retryable: action.retryable };
}
22}
23 
24function render<T>(state: RequestState<T>, view: (data: T) => string): string {
switch (state.status) {
  case "idle":
    return "Nothing loaded yet";
  case "loading":
    return "Loading\u2026";
  case "success":
    return view(state.data);
  case "error":
    return state.retryable
      ? `${state.error} \u2014 tap to retry`
      : `Failed: ${state.error}`;
  default: {
    const _exhaustive: never = state;
    return _exhaustive;
  }
}
41}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Discriminated unions let each state own only the fields that make sense for it, so impossible combinations become unrepresentable.
2Switching on the shared discriminant field narrows the type, giving you safe access to phase-specific data without casts.
3Assigning the remaining case to `never` turns a forgotten branch into a compile error, keeping switches in sync with the union.

Related explainers

typescript

import {
  Directive,
  Input,
  TemplateRef,

Building a structural *appUnless directive in Angular

structural-directive template-rendering dependency-injection

Intermediate 8 steps

typescript

type EventMap = Record<string, unknown[]>;
 
type Listener<Args extends unknown[]> = (...args: Args) => void;

A type-safe event emitter in TypeScript

generics mapped-types event-emitter

Advanced 8 steps

java

public final class Debouncer<T> {
 
    private final ScheduledExecutorService scheduler =
            Executors.newSingleThreadScheduledExecutor(runnable -> {

How a debouncer collapses bursts in Java

debounce concurrency scheduling

Intermediate 9 steps

typescript

import { inject } from '@angular/core';
import { ResolveFn, Router, ActivatedRouteSnapshot } from '@angular/router';
import { catchError, of, EMPTY } from 'rxjs';
import { Article } from './models/article';

Prefetching route data with an Angular resolver

route-resolver dependency-injection rxjs

Intermediate 6 steps

typescript

interface Order {
  id: number;
  customerId: string;
  total: number;

A type-safe groupBy in TypeScript

generics reduce type-inference

Intermediate 6 steps

typescript

import { Injectable, Logger } from '@nestjs/common';
import { Cron, CronExpression } from '@nestjs/schedule';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository, LessThan } from 'typeorm';