Literal types: single values as types, and the as const that keeps them

A single value, used as a type

Every primitive value can also be a type: "GET" is a type whose only inhabitant is the string "GET". Likewise 200, true, 42n. On their own these are rarely useful — but as unions they become precise, self-documenting domains:

type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
type StatusCode = 200 | 201 | 400 | 404 | 500;
type Toggle = true | false; // i.e. boolean

function request(method: HttpMethod, url: string) { /* ... */ }

request("GET", "/users");   // ✅
request("PATCH", "/users"); // Error: Argument of type '"PATCH"' is not
//                          //   assignable to parameter of type 'HttpMethod'.

A literal union is a closed set the checker enforces and your editor autocompletes. This is the most common “enum” in modern TypeScript — and it has zero runtime footprint.

Widening, revisited: where literals come from and get lost

You met widening in the inference lesson. Literals are exactly what widening throws away. The binding keyword decides:

let m = "GET";
//  ^? let m: string  — `let` widens; the literal is gone

const m2 = "GET";
//    ^? const m2: "GET"  — `const` keeps the literal

So const already gives you a literal for primitives. The trap is objects, where const does not reach into properties:

const config = { method: "GET" };
//    ^? const config: { method: string }  — property widened to string

request(config.method, "/x");
// Error: Argument of type 'string' is not assignable to parameter of type 'HttpMethod'.

Here’s the Hook’s bug exactly: config.method widened to string because the property is mutable, so it no longer fits the HttpMethod union. That’s the cost of structural typing meeting widening.

as const: deep, readonly, literal

The fix is a const assertion. as const does three things at once to its operand: makes every property readonly, prevents widening (keeps literal types), and turns array literals into tuples instead of arrays.

const config = { method: "GET", retries: 3 } as const;
//    ^? const config: { readonly method: "GET"; readonly retries: 3 }

request(config.method, "/x"); // ✅ now config.method is the literal "GET"

Watch it work top to bottom on nested data, arrays, and tuples:

const before = ["a", "b"];
//    ^? const before: string[]

const after = ["a", "b"] as const;
//    ^? const after: readonly ["a", "b"]  — a readonly tuple of literals

const route = { path: "/users", methods: ["GET", "POST"] } as const;
//    ^? const route: {
//         readonly path: "/users";
//         readonly methods: readonly ["GET", "POST"];
//       }

Without as const, methods would be string[]; with it, it’s the exact tuple readonly ["GET", "POST"]. This is the engine behind “config-as-types”: author a plain object literal, append as const, and derive types directly from the runtime value (typeof config, config["methods"][number]) — single source of truth, no duplication.

When widening bites — and the fix

The classic failure: a config object whose literal keys silently widen, then get rejected by a function expecting the literal union.

type Level = "debug" | "info" | "warn" | "error";

function setLevel(l: Level) { /* ... */ }

const settings = { level: "warn" };
setLevel(settings.level);
// Error: Argument of type 'string' is not assignable to parameter of type 'Level'.

// Fixes (pick one):
const settings2 = { level: "warn" as const };      // narrow one property
const settings3 = { level: "warn" } as const;      // narrow the whole object
const settings4 = { level: "warn" as Level };       // annotate to the target union

Any of these keep level precise enough to satisfy Level. The general lesson: when you build data destined for a literal-union slot, you must stop widening — either with as const or by typing the variable to the union directly.

Literal unions vs enum

Before you reach for enum, ask yourself: does this value need to exist as a runtime object, or do you just want the checker to reject anything outside a known set? Most of the time it’s the latter — which is exactly what literal unions do with zero runtime cost. Here’s how they compare:

Teams favor as const unions because they have no runtime cost, serialize transparently (the API sends "GET", not an opaque enum slot), and stay structural — a plain "GET" from anywhere just fits. enum still earns its place for bit flags or when you want a closed namespace object at runtime, but it’s no longer the default reach.