Infer fixed length heterogenous arrays as tuples

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]

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))

any updates on this?

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.

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

Navigation Menu

Repository navigation

Infer fixed length heterogenous arrays as tuples #13883

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Infer fixed length heterogenous arrays as tuples #13883

Description

Activity

phra commented on Apr 3, 2017

phra commented on Apr 30, 2017

kitsonk commented on May 1, 2017

jvanbruegge commented on May 1, 2017

phra commented on May 1, 2017

mhegazy commented on Feb 8, 2018

typescript-bot commented on Feb 22, 2018

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions