Bad type inference of function overloads

[gcnew]

TypeScript Version: 2.7.0-dev.20171110

Code

interface Leaf<T> {
    kind: 'leaf',
    data: T[]
}

interface Branch<T> {
    kind: 'branch',
    data: Trie<T>[]
}

type Trie<T> = Leaf<T> | Branch<T>

function mapTrie<T, U>(
    trie: Trie<T>,
    f: {
        (x: T): U,
        (x: Trie<T>): Trie<U>
    }
): Trie<U> {
    if (trie.kind === 'leaf') {
        return {
            kind: 'leaf',
            data: trie.data.map(f) // `f` should be inferred as `(x: T) => U`
                                   // works fine with explicit type param `map<U>(f)`
        };
    }

    return {
        kind: 'branch',
        data: trie.data.map(f)
    };
}

[mhegazy]

Please see #20257

[gcnew]

I don't think this issue a duplicate of #20257. While the underlying limitation might be the same, in #20257 there is no definite clue which overload is the expected one. In this issue, however, proper inference can be made following the types of the parameters.

What we know:

trie.data: T[]
expected mapper parameter: (x: T) => <some B>
provided mapper argument: ((x: T) => U) & ((x: Trie<T>) => Trie<U>)

We are looking for a B which can be deduced from f's signature. The following two options are present:

• (x: T) => <some B> ~ (x: T) => U)
• (x: T) => <some B> ~ (x: Trie<T>) => Trie<U>

The first option yields the correct solution B = U. The second one is not solvable, as T !== Trie<T>, so it should be discarded. What actually happens is that the second option creeps in, although it does not satisfy the first parameter's type x: T.

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

[gcnew]

@mhegazy Does my last comment change your view on this issue?

[mhegazy]

do not think so..