Dynamic Generation of TypeScript Function Overloads Using Union‑to‑Intersection Types

Overloading means a function can have different parameter lists and return types, i.e., multiple signatures. TypeScript supports function overloads and allows defining several signatures for the same function.

There are three ways to write overloads in TypeScript: declare function , interface , and using intersection types with & . Most developers only know one of them.

Example of the most common approach – declaring two functions with the same name:

declare function func(name: string): string;
declare function func(name: number): number;

Functions can also be declared via an interface , and overloads can be expressed with intersection types, but both become verbose when many signatures are needed.

To avoid writing many overloads manually, we can generate them dynamically using type programming. The key idea is to convert a union type into an intersection type, leveraging the contravariant nature of function parameters (a parameter that can accept A, B, or C is represented as A & B & C ).

Utility type UnionToIntersection implements this conversion:

type UnionToIntersection
=
    (U extends U ? (x: U) => unknown : never) extends (x: infer R) => unknown
        ? R
        : never;

Testing shows that a union of function signatures is transformed into an intersection, i.e., a single overload that accepts all cases.

The transformation relies on TypeScript’s distributed conditional types: when a union type appears on the left side of a conditional, the compiler evaluates the condition for each member separately and then recombines the results.

For illustration, a conditional type that upper‑cases the literal 'a' in a union:

type UppercaseA
=
    Item extends 'a' ? Uppercase<Item> : Item;

Returning to overload generation, we define a mapping from a key to its return type ( ReturnValueMap ) and then build a utility that turns a union of keys into an overload function type:

type UnionToOverloadFunction
=
    UnionToIntersection<
        T extends any ? (type: T) => ReturnValueMap[T] : never
    >;

Here T extends any triggers distribution, producing a union of function signatures, which UnionToIntersection collapses into an intersection – the desired overload set.

After testing the intermediate result, we combine it with UnionToIntersection to obtain the final dynamically generated overload function.

Compared with the manual declare function approach, the type‑programming solution is much cleaner and scales well when many overloads are required.

Summary

TypeScript function overloads can be expressed in three ways: declare function , interface , and intersection types. When overloads become numerous, writing them manually is tedious; using advanced type programming—specifically converting a union of signatures to an intersection via UnionToIntersection and distributed conditional types—allows dynamic generation of overload definitions.