Contextually allow spread to create tuples from tuples

[markusjohnsson]

Search Terms

tuple spread

Suggestion

Right now, I cannot create a 3-tuple from a 2-tuple using spread, like so:

type A = [number, number];
type B = [number, number, string];

const a: A = [1, 2];
const b: B = [...a, "asd"];

// Type '(string | number)[]' is missing the following properties from type '[number, number, string]': 0, 1, 2

But to me it seams that, given the expected type, TypeScript would be able to see that spreading a [number,number] and adding a string would create a [number, number, string].

Use Cases

Right now to produce a correct type B, given a value of type A, I would need to destructure and recreate the type:

const [x, y] = a;
const b: B = [x, y, "asd"];

Which works for simple tuples like this, but does not scale well.

Examples

I was working on a piece of code that looked like this:

type Result = [A, B];
function majorOperation(args) : Result  {
   const a = stuff();
   return minorOperation(a);
}

I then needed to expand the result of majorOperation to include another result, not produced by minorOperation(), so I split the result type in two and expected typescript to allow me to combine them using spread:

type MinorResult = [A, B];
type MajorResult = [A, B, C];
function majorOperation() : MajorResult  {
   const a = stuff();
   const c = produceC();
   return [... minorOperation(a), c];
}

Checklist

My suggestion meets these guidelines:

• 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, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[RyanCavanaugh]

@ahejlsberg was this an oversight? It seems correct to create a tuple in the presence of a tuple contextual type

[ahejlsberg]

@RyanCavanaugh No, not an oversight. Currently, anything past the first spread expression is unioned into a rest element in the resulting tuple type; and if the spread is in the first position, the result is an array type (because [...X] is the same as X[]). See also #26350.

[markusjohnsson]

Works as of TS 4.0