Tuple inference

Learn tuple inference in generics.

What is tuple inference?

Tuple inference is the inference of the tuple type from the arguments passed in a generic function call. In function f<T extends unknown[]>(...args: T): T, T is determined as the tuple of the ordered types of the parameters in the call. This provides type-safe tuple return with rest parameters.

function f<T extends unknown[]>(...args: T): T {
  return args;
}
f(1, "a", true);  // [number, string, boolean]

Tuple return with rest parameters

When a function returns rest parameters as a tuple, the return type preserves the type order of the call arguments. Unlike a normal array return, this keeps the element types and order fixed. So the call f(1, "a") returns [number, string].

Exercise Tuple returning function

Define a generic function named dondur: <T extends unknown[]>(...args: T): T. Its body should be return args. Assign the result of calling dondur(1, "a", true) to a variable named sonuc. Print sonuc[0] with console.log.

Show example solution

function dondur<T extends unknown[]>(...args: T): T {
  return args;
}
const sonuc = dondur(1, "a", true);
console.log(sonuc[0]);

Test yourself

In the call f(1, "a") to function f<T extends unknown[]>(...args: T): T, what is T?
- unknown[]
- [number, string]
- (number | string)[]
- any[]
Show answer

[number, string] — With rest parameters, the ordered types of the call arguments are inferred as a tuple; so T becomes [number, string], not a union array.

Rest parameter declaration

function f<T extends unknown[]>(____ args: T): T {
  return args;
}

Show answer

function f<T extends unknown[]>(... args: T): T {
  return args;
}

Tuple inference concepts

...args

Rest parameter
T extends unknown[]

Tuple constraint
[number, string]

Inferred tuple type
inference

Type inference

Next lesson: Recursive generic types

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies