Union Type made of two types of arrays fails to provide all array's methods

[OleksandrNechai]

TypeScript Version: 1.8.0 / TypeScript playground

Code

let x1: number[];
let x2: number[][];
x1.splice(1, 1); // OK
x2.splice(1, 1); // OK
let x: number[] | number[][];
x.splice(1, 1); // Error: Supplied parameters do not match any signature of call target.

Expected behavior:
TS tutorial states:

If we have a value that has a union type, we can only access members that are common to all types in the union.

Since both x1: number[]; and x2: number[][] have splice method with two params, I expect the union of these two types also to have this method.

Actual behavior:
Compiler reports an error: Supplied parameters do not match any signature of call target. However, it allows using another overload of splice function:

let x: number[] | number[][];
x.splice(1); // OK

[OleksandrNechai]

It is probably same issue as #10620

[kitsonk]

Yes, essentially it is the same, the subtle difference is that when matching the signature, it is matching one that it cannot union the overload:

interface Array<T> {
    splice(start: number): T[];
    splice(start: number, deleteCount: number, ...items: T[]): T[];
}

It cannot union the type of the ...items: T[] argument, therefore it causes an error. Technically if there was anther overload, the code above would work, up until the point where you added arguments that you needed to insert:

interface Array<T> {
    splice(start: number): T[];
    splice(start: number, deleteCount: number): T[];
    splice(start: number, deleteCount: number, ...items: T[]): T[];
}

But it is better to have (number | number[])[] in the first place as mentioned in the issue you referenced.

[OleksandrNechai]

But it is better to have (number | number[])[] in the first place

Well, then this code does not compile:

let x: (string[] | number[])[]
x.forEach(e => e.splice(1, 1)); // The same error

Unfortunately I have both cases in my code. Whatever way I choose to describe my types I get this error :-(.

[kitsonk]

This will work, but I suspect this is not what you want:

let x: (string | number)[][]
x.forEach(e => e.splice(1, 1));

As I suspect you want an array of array of all numbers or an array of arrays of all strings.

The other option would be to help TypeScript along:

let x: (string[] | number[])[];
x.forEach((e: any[]) => e.splice(1, 1));

[OleksandrNechai]

x.forEach((e: any[]) => e.splice(1, 1)); is pretty neat! Thanks!
I thought transition from C# would be much easier. TS turned out to be very different beast :-)

[kitsonk]

TS turned out to be very different beast

You can thank JavaScript for that... Coming from JavaScript to TypeScript (my path) is like finally getting medication to treat your insanity. Coming from C# must be like taking medical marijuana for the first time. Please don't let TypeScript be a gateway drug to the acid trip that is JavaScript though.

[RyanCavanaugh]

I think we should rewrite the signatures to be

interface Array<T> {
    splice(start: number, deleteCount?: number): T[];
    splice(start: number, deleteCount: number, ...items: T[]): T[];
}

with the observation that generic types should have signatures split according to their input use of their type parameters