.map() .reduce() .filter() methods fail with "This expression is not callable." error on valid array with union type

[IvanKalinin]

TypeScript Version: any

Code:

const arr: number[] | string[] = []; // Works with Array<number | string>
const arr1: number[] = [];
const arr2: string[] = [];

arr.map((a: number | string, index: number) => { 
 return index
})

arr.reduce((acc: Array<string>, a: number | string, index: number) => { 
 return []
}, [])

arr.forEach((a: number | string, index: number) => { 
 return index
})

arr1.map((a: number, index: number) => { 
 return index
})

arr1.reduce((acc: number[], a: number, index: number) => { 
 return [a]
}, [])

arr1.forEach((a: number, index: number) => { 
 return index
})
arr2.map((a: string, index: number) => { 
 return index
})

arr2.reduce((acc: string[], a: string, index: number) => { 
 return []
}, [])

arr2.forEach((a: string, index: number) => { 
 return index
})

Expected behavior: TS should let me iterate through array (I tell it the type is either array of numbers OR array of strings (not an array of mixed types). In any case the variable is an array and those methods should be callable.

Actual behavior: TS throws error "This expression is not callable."

[DanielRosenwasser]

I think this is a duplicate of #7294

[jcalz]

Duplicate of #7294 (see comment). Related to #29011.

Mentioned in documentation as caveats for improved behavior for calling union types:

This new behavior only kicks in when at most one type in the union has multiple overloads, and at most one type in the union has a generic signature. That means methods on number[] | string[] like map (which is generic) still won’t be callable.

[jcjolley]

Is this really a duplicate? The 'duplicate' issue is marked as closed, but this issue still exists. If it really is a duplicate, can we re-open #7294 to handle this case?

[dragomirtitian]

The reason stated by Wesley Wigham (@weswigham) for not unifying for generic signatures with multiple signatures is that:

Well, it's because we don't really know if the generics are the same (and so because of that we'd opt to make the parameter type T & T' instead and combine the type parameter lists to <T, T'>), so we opt to not allow the call.

But for function signatures originating from the same declaration we can be sure that we are talking about the same overload signatures in the same order and with the same generic parameters. As long as the generics don't have constraints, unifying the signatures should be safe IMO.

I think that unifying for this case would satisfy a lot of use cases. Array and Promise would benefit from this and those are the usual place people run into this limitation.

[weswigham]

Yeah, I have a change around here somewhere that allows it for exactly that situation rummages through bin of old PRs

[dragomirtitian]

Wesley Wigham (@weswigham) What was wrong with it? Why did it get stuck ? Can we revive it :D ?

[weswigham]

#31023 contains the relevant code. It's a bit old, and some parts of it are probably no longer needed thanks to some other signature resolution changes we made (namely the base signature stuff should no longer be needed).

[dragomirtitian]

Cool! So is this planned for a release in the future I'm guessing? I wanted to have a look at this over the weekend but glad to see it already there and we will get eventually :)

[eritbh]

Looks like my issue #36307 talks about pretty much the same behavior, linking for discoverability. Glad to see there's been some movement!