Infer fixed length heterogenous arrays as tuples

[jvanbruegge]

As the use of Heterogenous arrays for other purposes as tuples is minimal, I would change default inferance for fixed length heterogenous arrays to tuples to minimize the needed as statements in the code.

TypeScript Version: 2.1

const f : (s : string) => number = s => parseInt(s);
const arr : string[] = ['0', '1', '2'];

const res = arr
    .map(s => [s, f(s)]) //Should be infered as [string, number] not [string | number]
    .map(([s, n]) => f(s) + n); //Error: s has type number | string

Expected behavior:
the tuple has the infered type [string, number]

Actual behavior:
the tuple is typed [string | number]

[phra]

yeah, it would be nice. i just experienced the same issue.

Typescript version: 2.2.x

UNION TYPE INFERRED:

function* CounterGenerator(): IterableIterator<number> {
    let i = 1
    while (1) {
        yield i++
    }
}

function* StringGenerator(): IterableIterator<string> {
    let i = 1
    while (1) {
        yield String(i++)
    }
}

function getTuple()/*: [number, string]*/ { // return type stripped
    return [CounterGenerator().next().value, StringGenerator().next().value]
} 

const [x, y] = getTuple()

console.log(x + parseInt(y)) // tsc complains about y

NO ERRORS:

function* CounterGenerator(): IterableIterator<number> {
    let i = 1
    while (1) {
        yield i++
    }
}

function* StringGenerator(): IterableIterator<string> {
    let i = 1
    while (1) {
        yield String(i++)
    }
}

function getTuple(): [number, string] {
    return [CounterGenerator().next().value, StringGenerator().next().value]
} 

const [x, y] = getTuple()

console.log(x + parseInt(y))

[phra]

any updates on this?

[kitsonk]

It is really unsafe to infer tuple types... There is a lot of discussion on this in other issues. It would and could break a lot of other code where someone is using an array that they don't intend to be a tuple. You have to choose an order of precedence of assign types when they overlap, and choosing an array is far more logical and common than a tuple type. Just because an array literal is a const and is heterogeneous doesn't mean that it is intended to be a tuple. Especially because even with tuple types, all the run-time array functionality is available. It makes a lot of sense that tuples need to be explicitly declared as it demonstrates the intent of ambiguous code.

[jvanbruegge]

what is the use case of an heterogenous array that is not used as tuple? And it may be breaking, but I would assume only for a small amount of people and typescript had breaking changes before (2.1 -> 2.2).

[phra]

see also #15484

[mhegazy]

Duplicate of #12849

[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.