Feature Request: a rest parameter of type "Array of Tuples" should expand to a repeating parameter list of the Tuple's type #56776

🔍 Search Terms

Tuple, varargs, rest parameter, rest argument, function signature, variadic tuple types, spread syntax

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

Here is a playground demonstrating the functionality I expected from the function signatures:

declare const tupleRestParams: (
  input: string,
  ...translations: [string, string]
)=> string;

tupleRestParams("input", "a"); // errors as expected
tupleRestParams("input", "a", "b"); // compiles as expected
tupleRestParams("input", "a", "b", "c"); // errors as expected
tupleRestParams("input", "a", "b", "c", "d"); // errors as expected
tupleRestParams("input", "a", "b", "c", "d", "e", "f"); // errors as expected

declare const tupleArrayRestParams: (
  input: string,
  ...translations: [string, string][]
)=> string;

tupleArrayRestParams("input", "a"); // errors as expected
tupleArrayRestParams("input", "a", "b"); // unexpected error! expected this to compile
tupleArrayRestParams("input", "a", "b", "c"); // errors as expected
tupleArrayRestParams("input", "a", "b", "c", "d"); // unexpected error! expected this to compile
tupleArrayRestParams("input", "a", "b", "c", "d", "e"); // errors as expected
tupleArrayRestParams("input", "a", "b", "c", "d", "e", "f"); // unexpected error! expected this to compile

declare const multiTypeTupleArrayRestParams: (
  input: string,
  ...translations: ([string, number])[]
)=> string;

multiTypeTupleArrayRestParams("input", "a"); // errors as expected
multiTypeTupleArrayRestParams("input", "a", 1); // unexpected error! expected this to compile
multiTypeTupleArrayRestParams("input", "a", 1, "c"); // errors as expected
multiTypeTupleArrayRestParams("input", "a", 1, "c", 2); // unexpected error! expected this to compile
multiTypeTupleArrayRestParams("input", "a", 1, "c", 2, "e"); // errors as expected
multiTypeTupleArrayRestParams("input", "a", 1, "c", 2, "e", 3); // unexpected error! expected this to compile

📃 Motivating Example

I consider myself a newbie, but given the syntax of the above example, my expected behavior feels more intuitive than the actual behavior. In dynamically typed languages like JavaScript, a repeating sequence of types doesn't seem too unusual. At least, it's common throughout the Clojure API.

However, "a function with a repeating set of parameters" requires using some advanced types to pull off, AFAIK.

💻 Use Cases

1. What do you want to use this for? This is come up more than once while writing typescript, and not just for libraries. For example, I wanted to recreate linux's tr command with a signature like this:

   const tr = (
     input: string,
     ...translations: [string, string][]
   ): string => {
       return ""
   };
   

   I believe that signature means something different from my intention, therefore some additional syntax may be required.
2. What shortcomings exist with current approaches? Additional syntax may be required. It may already be possible to do this and I just don't know the syntax.
3. What workarounds are you using in the meantime? This can be achieved with recursive conditional types.