## Search Terms tuple type rest spread typescript ## Suggestion I'd like to be able to write tuple types using the spread operator. For example: ```typescript type Foo = [string, ...number[]]; // first elt must be string, rest must be numbers ``` Currently, this produces an error at the ellipsis: "Type expected". Here is a question asking much the same thing on Stack Overflow: https://stackoverflow.com/questions/44934541/how-to-use-the-spread-operator-in-a-typescript-tuple It seems related to https://github.com/Microsoft/TypeScript/issues/10727, but that issue focuses on Object rest/spread, whereas this is specifically about tuples. ## Use Cases Typed tuples are part of the existing language. So it seems natural that one should be able to type rest arguments . For example, if you want to represent a syntax tree, you might want to write: ```typescript type FunCall = ['FUNCALL', Symbol, ...Expression[]]; // error in 2.9.1 :( type Symbol = string; type Expression = FunCall | Scalar; type Scalar = number | string | null; ``` But this isn't allowed in Typescript 2.9.1. ## Examples ```typescript type Foo = [string, ...number[]]; const f1: Foo = ["str", 2, 3, 4]; // should pass const f2: Foo = ["str", "2", 3, 4]; // should fail: // "Type '(string | number)[]' is not assignable to type 'number[]'. const f2: Foo = ["str", 2, "3", 4]; // should fail: // "Type '(number | string)[]' is not assignable to type 'number[]'. const f1: Foo = [1, 2, 3, 4]; // should fail: // "Type 'number' is not assignable to type 'string'. ``` ## Checklist My suggestion meets these guidelines: * [x] This wouldn't be a breaking change in existing TypeScript / JavaScript code * [x] This wouldn't change the runtime behavior of existing JavaScript code * [x] This could be implemented without emitting different JS based on the types of the expressions * [x] This isn't a runtime feature (e.g. new expression-level syntax)