Allow inference of the type of the rest parameters.

[rzvc]

Search Terms

rest parameters infer conditional types

Suggestion

Allow type inference for rest parameters:

type ArgumentsType<T extends (...args: any[]) => any> = T extends (...args: infer R) => any ? R : any[];

Currently the compiler complains that rest parameters have to be an array type, but if the full type of the rest parameters could be inferred (as a tuple), then you could extract the type of the parameters of a function, allowing you to do something like this:

function f(a: number, b: string) : void
{
}

let params : ArgumentsType<typeof f> = [10, 'test'];

Furthermore, allowing the rest parameters to have a type, would then allow typed forwarding:

function f2(extra: bool, ...rest: ArgumentsType<typeof f>) : void
{
	f(...rest);
}

[s-ve]

If I'm not mistaking, #5453 already covers your suggestion 😊

[rzvc]

@s-ve Thanks for that. It looks like it does cover this usage, but my suggestion should be far easier to implement, because it doesn't require an additional kind of types.

Also, I'm not sure variadic kinds are needed to specify a tuple, since the type of rest parameters is already a tuple, so T should be enough (instead of ...T), as long as T is a tuple. They would be needed however to specify types of arbitrary length.

// For example, you don't need variadic kinds for this:
function f(...rest: [number, string]) : void;

// But you need for this:
function f(...rest: [number, string, ...boolean]) : void;

With the above examples in mind, it becomes obvious that you don't need variadic kinds for the type inference of rest parameters, because at the time when the inference is done, the tuple is already known.

Edit, I'd also like to link this here, which proposes a similar thing: #5331

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.