Value of type T is not assignable to T & U even when T extends U

[Muon]

At least in the case of U being a nonempty finite union of singleton types, it seems that T extending U does not imply that T is assignable to T & U, even though every value of type T is also a value of type U.

However, the distributive conditional type T extends U ? T : never is considered assignable to U even though it should have the same set of values as T since we assume that T extends U.

TypeScript Version: 3.5.1 and 3.7.0-dev.20190907

Search Terms: enum intersection extends not reduced

Code

type A = 1 | 2;
function f<T extends A>(a: T): A & T  { return a; } // Error: Type '1' is not assignable to type '2'.
function g<T extends A>(a: T extends A ? T : never): A & T  { return a; } // OK

Expected behavior: Compiles.

Actual behavior: Does not compile.

Playground Link: https://www.typescriptlang.org/play/index.html#code/C4TwDgpgBAglC8UCMUA+UBMBuAUAMwFcA7AY2AEsB7IqPAHgBUoIAPYCIgEwGdYA+ABQBDAFxQGASjFwAZOKhQA3lABOEYARU0hWKAF8gA

Related Issues: #28830

For context, I am attempting to write a function that takes a union tag and a payload and returns a matching new instance of one of the members of a tagged union.

Here is some further exploration in that direction: https://www.typescriptlang.org/play/index.html#code/C4TwDgpgBAglC8UCMUA+UBMBuAUAMwFcA7AY2AEsB7IqPAHgBUoIAPYCIgEwGdYA+ABQBDAFxQGASjFwAZOKhQA3lABOEYARU0hWKAF98xMlRoBzRszYce-YWKat2XXnAD88sUQgA3CCqmwUHJMSqrqmtq6BjjkROwqeEIk0ACySjgKCqLIuAax8YnJUABy6ZlQ2dg40YSkFNRQABYWjtYugtmSYgIpqMUSQUqdegrKahpaQ3pRhnUmUOQtVs62nZZONm4eUF6+-t29-YOKw6NhEzQn0-pQs8YNAFZLG+12Q-YjrSuHUO5Mnj4-AEen0BnITh8zuMIlMZrV7jQANbPNqBDr2daorb-HaA-bvcSfZY2EFHdwQhgjcGnAF7ULQyZXOFGeo0AA2KJWMHRBMpmJWpLBvJGv22uyBB1Bx1O9PCjKE1z0QA

[poseidonCore]

You need to be careful with literal types because they don't always work the way that other types work. Consider whether you really want to union or intersect.

type A = 1 | 2;
function f1<T extends A>(a: T): A | T  { return a; }

type B = {n: 1 | 2};
function f2<T extends B>(b: T): B & T  { return b; }

TS Playground

[Muon]

I definitely want to intersect, since I want to narrow, not widen. In that example, A | T is just A. The second case isn't quite what I'm interested in, since I want to construct one of the two narrowed versions of B from a fixed value of n.

[poseidonCore]

Got you: so there is a cascade of failures in type comparisons where TS looks at f and doesn't see that it should be equivalent to writing the longhand g.

type A = 1 | 2;
function f<T extends A>(a: T): A & T  { return a; }
/*
Type 'T' is not assignable to type '(1 & T) | (2 & T)'.
  Type 'A' is not assignable to type '(1 & T) | (2 & T)'.
    Type '1' is not assignable to type '(1 & T) | (2 & T)'.
      Type 'T' is not assignable to type '2 & T'.
        Type 'A' is not assignable to type '2 & T'.
          Type '1' is not assignable to type '2 & T'.
            Type '1' is not assignable to type '2'.
              Type 'T' is not assignable to type '2'.
                Type 'A' is not assignable to type '2'.
                  Type '1' is not assignable to type '2'.
*/

function g<T extends A>(a: T extends A ? T : never): A & T  { return a; }

[jack-williams]

This does not look right; even this form of g works:

type A = 1 | 2;
function g<T>(a: T extends A ? T : never): A & T  { return a; } // OK

Basically when attempting to assign T to the intersection it falls back to the constraint entirely, forgetting that it was generic; unfortunately, the type needs to be both generic and A to work.

The conditional type works because T in the true branch is actually a substitution type which is basically like an intersection T & A, so it precisely has the generic and concrete qualities you need.

I wonder if a type parameter can fall back to an intersection if it fails generally.

[RyanCavanaugh]

This is kind of confusing - the constraint already implies (a certain kind of) assignability from T to A, so returning T & A is a more confusing way of returning T.

@weswigham thoughts?

[weswigham]

function f<T extends A>(a: T): A & T { return a; } is
function f<T extends 1 | 2>(a: T): T & 1 | T & 2 { return a; } after distribution. T's constraint isn't assignable to that (it's missing T), and T itself isn't assignable (since those non-T components exist). We're missing a rule where we distribute a type paramter's constraint (should it be a union) onto the type parameter itself in order to handle scenarios like this one.