Rest Parameters

Basic rest parameters with ...args: type[] are great, but sometimes you need more precision. TypeScript lets you type rest parameters using tuple types, which give you exact control over the number and types of arguments. This is where rest parameters get really powerful.

The simplest tuple rest looks like this:

function send(...args: [string, number]): void {
  const [message, priority] = args;
  console.log(`Msg: ${message}, Priority: ${priority}`);
}

send("Hello", 1);   // ✅ Exactly 2 args — string then number
send("Hi");          // ❌ Error: Expected 2 arguments
send("Hi", 1, 2);   // ❌ Error: Expected 2 arguments

With ...args: [string, number], the function must receive exactly two arguments — the first a string, the second a number. They get collected into a tuple, not a loose array. This is incredibly useful for type-safe wrappers, decorators, and callback signatures where the exact shape matters.

Now here's where it gets interesting — the "leading element + rest" pattern. You can mix a fixed first element with a rest tail inside the tuple:

function query(...args: [string, ...(string | number)[]]): void {
  const [sql, ...params] = args;
  console.log("SQL:", sql, "Params:", params);
}

query("SELECT * FROM users");                     // sql = "SELECT * FROM users", params = []
query("SELECT * FROM users WHERE id = ?", 42);    // sql = "SELECT * FROM users WHERE id = ?", params = [42]
query("INSERT INTO logs VALUES (?, ?, ?)", 1, "login", "success");

This pattern — [string, ...(string | number)[]] — means: the first argument must be a string (the SQL query), and then any number of additional arguments that are either strings or numbers (the parameter values). You get type safety on the first arg AND flexibility on the rest. This is exactly how real database query functions work.

Another common pattern — requiring at least one argument:

function max(...nums: [number, ...number[]]): number {
  return Math.max(...nums);
}

max(5);           // ✅ At least 1 number required
max(3, 7, 2);     // ✅
max();            // ❌ Error: Expected at least 1 argument

With ...nums: number[], calling max() with zero arguments is valid (the array is just empty). But with ...nums: [number, ...number[]], you guarantee at least one number. The first slot of the tuple is required, and the rest is optional. This prevents the bug where Math.max() returns -Infinity when called with no arguments — a classic JavaScript footgun.

Why use rest instead of the old arguments keyword? Three reasons: (1) arguments is not a real array — no .map(), .reduce(), .filter() without conversion. (2) arguments is untyped — TypeScript can't enforce what goes in. (3) arguments doesn't work in arrow functions at all. Rest parameters solve all three problems — they're real arrays, they're typed, and they work everywhere. Always prefer rest over arguments.