When should you use overloads instead of a union parameter?

A union parameter is usually the smaller API. If a function accepts string | string[] and returns the same type for both, one signature is enough. Overloads become valuable when the return type changes based on which argument was passed, because a union signature would force callers to narrow the result.

function parse(value: string): string[];
function parse(value: string[]): string;
function parse(value: string | string[]): string | string[] {
  return Array.isArray(value)
    ? value.join(",")
    : value.split(",");
}

const parts = parse("a,b,c");
const joined = parse(["a", "b", "c"]);

How to choose

• Use a union when every case returns the same type
• Use overloads when the return type is tied to the input type
• Use a generic conditional type when the relationship is systematic
• Overloads are easier for callers to read than a complex conditional type
• A union is easier to handle exhaustively inside the implementation

Overloads and unions are not mutually exclusive. A common pattern is a small set of overloads backed by one implementation that accepts a union. The overloads document the public call shapes; the union keeps the implementation simple. If the overload list grows beyond a few entries, reconsider the API.