Indexed access lookup on enum type could produce specific key types

[jfw225]

Suggestion

Per the documentation, it is possible to reverse map an enum at runtime:

enum Enum {
  A,
}
 
let a = Enum.A;
let nameOfA = Enum[a]; // "A"

However, suppose we wanted to get the type of the enum name from the enum value at compile time. That is, get some type T = "A" from Enum.A. From the example above, we would expect something like the following to work:

type T = typeof Enum[Enum.a]; // evaluates to string rather than "A"

const A: T = "A"; // compiler has no issues
const B: T = "B"; // compiler has no issues

As written above, the compiler fails to get the correct type. However, I have found a workaround:

type T = keyof { [K in keyof typeof Enum as typeof Enum[K] extends Enum.A ? K : never]: any }; // evaluates to "A"

const A: T = "A"; // compiler has no issues
const B: T = "B"; // compiler now throws a fit as expected

It would be nice if this could be abstracted away from the developer.

[fatcerberus]

type T = Enum[Enum.A]?

[jfw225]

Same goes if you try

type EnumKey = keyof typeof Enum // "A"
type EnumValWrong = Enum[EnumKey] //  Property "A" does not exist on type "Number"
type EnumVal = typeof Enum[EnumKey] // Enum.A

Thus, you need the typeof in front of what you wrote:

// type T = Enum[Enum.A];
type T = typeof Enum[Enum.A];

But as I said above, this evaluates to string rather than "A".

[jcalz]

Isn’t this a duplicate of #38806?

[jfw225]

Isn’t this a duplicate of #38806?

Potentially. I read that post as more of an issue reporting that what you would expect to work did not work for that specific case. I opened this to offer a more general suggestion for the problem rather than report an issue since the problem mentioned in #38806 can be solved with the workaround I mentioned above.

My apologies if this is a duplicate--this is my first issue on the repo. I did find #38806 before I posted this and linked this thread afterward as a solution to their problem.

[RyanCavanaugh]

You're basically asking for a type alias to do a thing you can already today in userland, which isn't something we do.

[RyanCavanaugh]

A simpler form is

type KeyHelper<E, K extends keyof E, V> = K extends unknown ? E[K] extends V ? K : never : never;
type KeyName<E, V> = KeyHelper<E, keyof E, V>;
type TheKeyName = KeyName<typeof Enum, Enum.B>;

[jfw225]

Thank you for providing a simpler form of the type alias. I appreciate the thought that went into your reply. Maybe you can help me better understand my underlying confusion.

You're basically asking for a type alias to do a thing you can already today in userland, which isn't something we do.

Okay, that makes sense. However, I feel like T should evaluate to "A" rather than string in the following example. Wouldn't this be the expected functionality given the reverse-mapping showcased in the documentation?

const nameOfA = Enum[Enum.A]; // evaluates to "A"
type T = typeof Enum[Enum.A]; // evaluates to string

It's entirely possible (probably likely) that this functionality is intended and there is something that I am missing. I would be interested to hear your thoughts on the advantages of the current implementation.

[RyanCavanaugh]

No reason it couldn't be the more-specific type "A"; that's just a feature that no one has implemented (or even proposed) as of yet.

[fatcerberus]

@RyanCavanaugh I kind of get the impression this issue counts as that proposal (and you tagged it Declined 😉).

From the example above, we would expect something like the following to work:

type T = typeof Enum[Enum.a]; // evaluates to string rather than "A"

const A: T = "A"; // compiler has no issues
const B: T = "B"; // compiler has no issues

[RyanCavanaugh]

Well, fair 😅