Assign tuple to object: Number is not assignable to type literal

[mstn]

TypeScript Version: 3.0.0-dev.20180602

Search Terms:

number is not assignable with type literal, tuple assigned to object, fixed size tuples

Code

// Type Error: number is not assignable with type 2
let p0: { length: 2 } = [1, 2]; 
// ok
let p1: { length: 2, 0: number } = [1, 2]
// ok
let p2: { 0: number } = [1, 2]

Expected behavior:

After that, [number, number] type should be equivalent to:

interface Tuple extends Array<number> {
    0: number;
    1: number;
    length: 2;
}
let t: Tuple = [1, 2];
// no syntax error
let obj: { length: 2 } = t;

Hence, I would expect let p0: { length: 2 } = [1, 2]; to be correct.

Please not that let p1: { length: 2, 0: number } = [1, 2]; is allowed.

Actual behavior:

let p0: { length: 2 } = [1, 2]; is not correct and gives error Number is not assignable to type 2.

Playground Link:

Playground snippet

[DanielRosenwasser]

Right now an array is only considered a tuple if it's contextually typed by a tuple-like type, which is really any type with a 0 property. We could consider including length in there. Is there a use-case you had in mind?

[mstn]

@DanielRosenwasser thanks for your answer.

If I understand correctly, you are saying that I can assign tuples only to tuple-like objects (= must have 0 property). I was thinking that, in Javascript, an array is an object and, in Typescript, it could make sense to see a tuple as a generic object, too.

I do not have a real use-case. I stumbled upon this feature while I was playing around with fixed size tuples in an attempt to define generic arrays of fixed size, such as,

// array of length 2 with items of type string
let d: FixedSizeArray<2, string>;

[AnyhowStep]

What I do for tuples,

https://github.com/AnyhowStep/typed-orm/blob/master/src/main/declaration-v2/tuple.ts

If you need a tuple of length 2, you need to check that it had the indices "0" and "1"

If you need a tuple of length 3, "0", "1", "2"

Just "0" and "length" are not really "enough" to guarantee those indices exist, after all.

I personally have no use for fixed length tuples. So, my type declarations make no reference to forcing it.

But I imagine, without "native" support for tuples of fixed length, you can implement it with copy pasting code (or writing a for-loop) and conditional types.

But using { length : number } isn't enough to guarantee the indices

[RyanCavanaugh]

I think tuple-typing anything contextually typed by a length property is going to have too many false positives, and it's actually a bit of a perf hit to do anything more complex here. If people aren't hitting this in practice then I'm comfortable calling this the intended behavior ; as const is a common requirement in these scenarios.