Intersection of function types

[jishi9]

TypeScript Version: 2.7.0-dev.201xxxxx

Code

class Foo {
    foo(): number {
        return 3;
    }
}

const x:
    { foo: (() => number) | (() => string) }
    & { foo: (() => number) } = new Foo();

const value: number = x.foo();

Expected behavior:
Compiles, because the (A|B) & A == A

Actual behavior:
Assignment to 'value' fails with:
Type 'string | number' is not assignable to type 'number'.

Background
Aside being a correctness issue, the motivation here is to enable type guards which narrow the return type of a function:

interface Producer {
    onlyMakesNumber(): this is {makeThing: () => number};

    makeThing(): string|number;
}

interface NumberProducer extends Producer {
  makeThing(): number;
}

function produceNumber(p: Producer) {
  if (p.onlyMakesNumber()) {
    const x: number = p.makeThing();  // compile error.

    const p2: NumberProducer = p;
    const y: number = p2.makeThing();  // compiles.
  }
}

[jcalz]

You expect the TypeScript compiler to implement the absorption laws, but it doesn't. There's also a wrinkle here that intersection of function types are interpreted as overloads, so that could possibly complicate how absorption would work with function types. 🤷‍♂️

[DanielRosenwasser]

Like @jcalz said, (A | B) & A is actually A | (A & B), and intersections of object types don't obliterate each other to never - they're purely additive.

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