✨ Add a matcher for tagged unions

src/tagged-union.ts

@@ -0,0 +1,135 @@
+import type { Exact, ValueOf } from "type-fest";
+
+type UnaryFn<T, R> = (shape: T) => R;
+
+// A tagged union is discriminated by one property whose values are the tags.
+// Only `string` and `number` tags can key a handler map: `symbol` has no
+// literal syntax to write a handler under, and `bigint` is not a property key.
+type Tag = string | number;
+
+// The discriminant values of `T` under `K`. `Extract` keeps the finite literal
+// tags and leaves a widened `string`/`number` as itself, so an open universe
+// keeps an open fallback.
+type Tags<T extends object, K extends keyof T> = Extract<T[K], Tag>;
+
+// The keys of `T` that can act as a discriminant. `getTaggedUnionMatcher<T>()`
+// accepts only these, so the factory rejects a key whose values are not tags.
+type Discriminated<T extends object> = {
+    [K in keyof T]: T[K] extends Tag ? K : never;
+}[keyof T];
+
+// The member(s) of `T` tagged `V`. `Extract` distributes over the union, so a
+// duplicated tag maps to a union of members rather than silently dropping one.
+type MapTaggedUnion<T extends object, K extends keyof T> = {
+    [V in Tags<T, K>]: Extract<T, Record<K, V>>;
+};
+
+type Handlers<T extends object, K extends keyof T, R> = {
+    [V in Tags<T, K>]: UnaryFn<MapTaggedUnion<T, K>[V], R>;
+};
+
+// `Extract` drops optional handlers (`undefined`) so `PatternReturns` also works
+// when `P`'s constraint has optional keys.
+type PatternReturns<P> = ReturnType<
+    Extract<ValueOf<P>, (...args: never[]) => unknown>
+>;
+
+// The members `Handled` covers. Mapping over `Tags` keeps every index within
+// `MapTaggedUnion`'s keys, and the conditional drops a stray key outside `T` so
+// it cannot widen the remainder. The remainder is `Exclude<T, …>`, mirroring
+// the primitive matcher's `Exclude<T, PatternParam<keyof Handled>>`.
+type HandledMembers<T extends object, K extends keyof T, Handled> = {
+    [V in Tags<T, K>]: V extends keyof Handled
+        ? MapTaggedUnion<T, K>[V]
+        : never;
+}[Tags<T, K>];
+
+// The fallback is a *second argument*, not a property of the handler map, so
+// its parameter can be the remainder the map left open. See development/library.md.
+type Fallback<T extends object, K extends keyof T, Handled, R> = UnaryFn<
+    Exclude<T, HandledMembers<T, K, Handled>>,
+    R
+>;
+
+// A fallback is redundant once the handler map covers every tag of `T`. Folded
+// into `Handled`'s own (self-referential) constraint so it is checked *after*
+// inference; see the primitive matcher for why a conditional in the fallback's
+// parameter is evaluated too early.
+interface RedundantFallback {
+    readonly "every case is already handled, so the fallback is redundant": never;
+}
+type MustBePartial<T extends object, K extends keyof T, Handled> =
+    Tags<T, K> extends keyof Handled ? RedundantFallback : unknown;
+
+// TypeScript does not apply the excess-property check to a generic constraint,
+// so `Exact` restores it for the generic forms.
+
+// oxlint-disable typescript/unified-signatures
+// Strict returns: one common `R`. Overload order is load-bearing:
+//   #1 Handlers (first) -> the exhaustive form and the autocomplete popup
+//   #2 Fallback (last)  -> accepts a partial handler map plus a fallback
+interface TaggedUnionMatcherStrict<T extends object, K extends keyof T> {
+    <R>(handlers: Handlers<T, K, R>): UnaryFn<T, R>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, K, R>>, Handled> &
+            MustBePartial<T, K, Handled>,
+    >(
+        handlers: Handled & Partial<Handlers<T, K, R>>,
+        fallback: Fallback<T, K, Handled, R>,
+    ): UnaryFn<T, R>;
+}
+// oxlint-enable typescript/unified-signatures
+
+// Widened returns: the union of every handler's return type. `P` is inferred
+// from the whole handler map, whose closed constraint supplies the
+// contextual/autocomplete type.
+// oxlint-disable typescript/unified-signatures
+interface TaggedUnionMatcherWidening<T extends object, K extends keyof T> {
+    <P extends Exact<Handlers<T, K, unknown>, P>>(
+        handlers: P,
+    ): UnaryFn<T, PatternReturns<P>>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, K, unknown>>, Handled> &
+            MustBePartial<T, K, Handled>,
+    >(
+        handlers: Handled,
+        fallback: Fallback<T, K, Handled, R>,
+    ): UnaryFn<T, PatternReturns<Handled> | R>;
+}
+// oxlint-enable typescript/unified-signatures
+
+type HandlerMap = Record<string | number, UnaryFn<never, unknown> | undefined>;
+
+// `object` carries no index signature, so the read needs the assertion; the
+// factory admits only keys whose values are `string | number` tags, so the
+// result is narrowed to the map's key space.
+const tagAt = (shape: object, k: PropertyKey): string | number =>
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    (shape as Record<PropertyKey, unknown>)[k] as string | number;
+
+const dispatch =
+    (k: PropertyKey) =>
+    (handlers: HandlerMap, fallback?: UnaryFn<never, unknown>) =>
+    (shape: object): unknown =>
+        (
+            handlers[tagAt(shape, k)] ??
+            fallback ??
+            (() => {
+                throw new Error(`Unhandled tag: ${String(tagAt(shape, k))}`);
+            })
+        )(
+            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+            shape as never,
+        );
+
+export const getTaggedUnionMatcher =
+    <T extends object>() =>
+    <K extends Discriminated<T>>(k: K): TaggedUnionMatcherStrict<T, K> =>
+        dispatch(k);
+
+export const getTaggedUnionMatcherW =
+    <T extends object>() =>
+    <K extends Discriminated<T>>(k: K): TaggedUnionMatcherWidening<T, K> =>
+        dispatch(k);