Enum generic does not restrict union of possible objects where enum is defined about typescript HOT 9 CLOSED

There's definitely many duplicates of this

#27808, extends oneof issue, I've seen too many of them.

@noahtallen just use the distributive behavior to make it work

function doSomethingWithData<T extends SomeThings>({thing, data}: T extends unknown ? ArgType<T> : never) {
  if (thing === SomeThings.One) {
    console.log(data.x); // OK
  }
}

Note that you also have to make the literal object foo declared as const.
const foo = {thing: SomeThings.One, data: {x: 1}} as const;

from typescript.

Hm interesting. It's odd to me that something like T extends T ? ... : never is required to get inference to work, given that T always extends T. So this is basically just tricking/forcing the compiler to distribute here?

Either way, happy that there's a solution!

from typescript.

Because within the function the compiler doesn't know which type is passed along. It could be SomeThings.One, it could be SomeThings.Two, it could also be the type SomeThings.One | SomeThings.Two. There's definitely many duplicates of this, just don't have one at hand right now.

from typescript.

The compiler should be able to know that SomeThings.One was passed within this block. It should also be know (based on the contracted specified by the ArgType interface) that it's impossible to pass mismatched arguments where the data doesn't match the enum:

// We know which one was passed now:
  if (thing === SomeThings.One) {
    console.log(data.x);
  }

// Correctly shows an error, so it does narrow the type of `data` based on the enum here:
doSomethingWithData({thing: SomeThings.One, data: {y: 'xyz'});

I think it evaluates ArgType<T> too early into a union of all possible values, where if it evaluated it within the if statement, it should know that it resolves to a single possibility

from typescript.

You misunderstand how generics work. Just because thing equals SomeThings.One does not mean you're dealing with a { x: number } data.

This is a perfectly valid and legal call:
doSomethingWithData<SomeThings.One | SomeThings.Two>({ thing: SomeThings.One, data: { y: "abc" }})

from typescript.

That's great, thanks for sharing! looks like as const isn't needed if you do:

const foo: ArgType<SomeThings.One> = {thing: SomeThings.One, data: {x: 1}};

if (someCondition) {
  foo.data.x = 100;
}

// works!
doSomethingWithData(foo);
doSomethingWithData({ thing: SomeThings.Two, data: {y: 'hi'}});

Anyways, I'm curious how this works. Why T extends unknown when T is known?

ts playground

from typescript.

Why T extends unknown when T is known?

Because unknown is the top type that anything can be assigned to it, to make sure that the conditional type always get in the "true" branch. You can replace it with T extends any or T extends T, all of them are OK.

And for "distributive" behavior, see https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types.

from typescript.

So this is basically just tricking/forcing the compiler to distribute here?

Yes. Conditional types distribute over type parameters, so:

type ArrayOf<T> = T extends T ? T[] : never;
type Test = ArrayOf<string | number>;  // string[] | number[];

whereas without distribution you’d get (string | number)[] instead.

from typescript.

#58634 (comment)

from typescript.