Union inference works in only some cases

[pelotom]

TypeScript Version: 2.8.1

Search Terms:

union inference

Code

let result: string | number

// Works
const fromArray = <Z>(cases: Z[]): Z => cases[0];
result = fromArray(['a', 3]);

// Doesn't work
const fromTuple = <Z>(cases: [Z, Z]): Z => cases[0];
result = fromTuple(['a', 3]);

// Doesn't work
const fromVarargs = <Z>(...cases: Z[]): Z => cases[0];
result = fromVarargs('a', 3);

// Works
const fromStringIndex = <Z>(cases: { [k: string]: Z }): Z => cases.x;
result = fromStringIndex({ x: 'a', y: 3 });

// Doesn't work
const fromRecord = <Z>(cases: { [K in 'x' | 'y']: Z }): Z => cases.x;
result = fromRecord({ x: 'a', y: 3 });

Expected behavior:

All of these examples should work, with the type parameter Z being inferred as the union of the types of all values provided.

Actual behavior:

Only the array and string index cases work.

Playground Link

[RyanCavanaugh]

If you have exactly one place where Z occurs, then you have exactly one inference candidate, and we choose that candidate. There's not something else we even could do.

If you have more than one place where Z occurs, then you have multiple inference candidates; we intentionally don't synthesize a union type to construct a new type such that all candidates are satisfied. See #805 (comment) for an old and long discussion of why. The previous behavior here, inferring a different supertype-of-both (which people hated), was tracked by #360.

[pelotom]

If you have more than one place where Z occurs, then you have multiple inference candidates; we intentionally don't synthesize a union type to construct a new type such that all candidates are satisfied.

Ok, but in some cases a union type is being synthesized (the array and string-indexed objects). I could understand if it never worked, but the fact that it works in some specific cases is what's confusing to me.

[RyanCavanaugh]

More specifically, we don't synthesize union types as part of inference. In any place where the call succeeds, the type (string | number)[] is already present in one of the sourcing expressions. Comments inline:

let result: string | number

// Works
const fromArray = <Z>(cases: Z[]): Z => cases[0];
// The array literal has the type (string | number)[] - we didn't synthesize that during inference
result = fromArray(['a', 3]);

// Doesn't work
const fromTuple = <Z>(cases: [Z, Z]): Z => cases[0];
// Z gets two candidates: string, number
// The array literal's type is not observed during inference
result = fromTuple(['a', 3]);

// Doesn't work
const fromVarargs = <Z>(...cases: Z[]): Z => cases[0];
// Z gets two candidates: string, number
// The union type string | number doesn't exist anywhere
result = fromVarargs('a', 3);

// Works
const fromStringIndex = <Z>(cases: { [k: string]: Z }): Z => cases.x;
// The fresh object literal has an index signature to string|number
result = fromStringIndex({ x: 'a', y: 3 });

// Doesn't work
const fromRecord = <Z>(cases: { [K in 'x' | 'y']: Z }): Z => cases.x;
// Each property maps to a Z so we have two candidates: string, number
result = fromRecord({ x: 'a', y: 3 });

[pelotom]

I see, thanks for the explanation!