Overloaded Union Return Types

[kitsonk]

Stupid question of the day, why does this not work:

class A {
    foo: string;
}

class B {
    bar: string;
}

class C {
    qat: string;
}

class D {
    baz: string;
}

function c(a: A): C;  /* Overloaded signature not compatible with function implementation */
function c(b: B): D;
function c(a: A|B): C|D {
    if (a instanceof A) {
        return new C();
    }
    else {
        return new D();
    }
}

Where as this is valid:

function c(a: A): C|D;
function c(b: B): C|D;
function c(a: A|B): C|D {
    if (a instanceof A) {
        return new C();
    }
    else {
        return new D();
    }
}

I am allowed to "delegate" the sorting out of the typing of my argument to my overloaded function implementation, but, I am not allowed to delegate the return type, though I am contracting to only return to return a certain type of return value (which is what I am doing with the handling arguments). Is there a good reason I am missing?

[nycdotnet]

It's a good question. See #1805. There's been talk of implementing a special case for this, but I haven't seen it yet.

[DanielRosenwasser]

It's actually not quite related to that @nycdotnet.

It's actually in the spec. From 6.1 Function Declarations:

If a function declaration includes overloads, [...] the function implementation signature must be assignable to that type.

C | D isn't assignable to either C or D; in fact, it's the reverse (C and D are each assignable to C | D).

This leaves me wondering whether there's a better way to do this or if we need to reconsider this rule in the spec.

[kitsonk]

Hmm... That does feel reversed. Obviously the use case is that having determined which override is being invoked, the implementation is contracting to return that type, thereby not requiring further type disambiguqtion by the consumer.

[RyanCavanaugh]

See #943

[kitsonk]

Yup, it is a duplicate of #943. I will take a look there.