Function Overloads & Call Signatures

Some functions genuinely behave differently depending on the shape of the arguments passed in, not just their values. A single generic signature can't always express that precisely, overloads let you describe several valid call shapes for the same function.

function createTask(title: string): { id: string; title: string };
function createTask(title: string, priority: 'low' | 'medium' | 'high'): { id: string; title: string; priority: string };
function createTask(title: string, priority?: 'low' | 'medium' | 'high') {
  const base = { id: crypto.randomUUID(), title };
  return priority ? { ...base, priority } : base;
}

const a = createTask('Write lesson');                 // typed as { id: string; title: string }
const b = createTask('Write lesson', 'high');          // typed as { id: string; title: string; priority: string }

The first two signatures are overload signatures, they describe the valid ways to call createTask from the outside. The third, with a body, is the implementation signature, it must be compatible with every overload above it, but callers never see it directly, only the overloads are checked against call sites. This is how a and b end up with two genuinely different, more precise return types instead of one overly-broad union.

Typing callable objects

A type can also describe something that's callable, not just an object with properties.

interface Logger {
  (message: string): void;      // Logger itself is callable...
  level: 'debug' | 'info' | 'error'; // ...and also has a property
}

const log: Logger = Object.assign(
  (message: string) => console.log(`[${log.level}] ${message}`),
  { level: 'info' as const }
);

log('server started'); // calling it directly
log.level;              // and reading a property off it

A call signature inside an interface, (message: string): void with no name, describes "this thing can be invoked like a function." Combined with an ordinary property, it types values that are both callable and carry extra data, a real pattern for loggers, event emitters, and similar utilities.