String literals not evaluate to string enum values.

[electricessence]

TypeScript Version: 2.8.0

Search Terms:
string literal enum

Code

const enum TypeOfValue
{
	Boolean   = 'boolean',
	Number    = 'number',
	String    = 'string',
	Symbol    = 'symbol',
	Object    = 'object',
	Undefined = 'undefined',
	Function  = 'function'
}
if(typeof x==TypeOfValue.String) {
    // Type guard fails for string.
}

Expected behavior:
The code in the within the if block should understand that x is a string.

Actual behavior:
The if block is unaware of the type.

[MartinJohns]

To expand on this, the same behavior happens with matching string literal types.

type TypeOfValue = 'boolean' | 'number' | 'string' | 'symbol' | 'object' | 'undefined' | 'function'

const TypeOfValueLookup: { readonly [P in TypeOfValue]: P } = {
    boolean: 'boolean',
    number: 'number',
    string: 'string',
    symbol: 'symbol',
    object: 'object',
    undefined: 'undefined',
    function: 'function'
}

if (typeof x === TypeOfValueLookup.string) {
    // x is not narrow to type string here.
}

[MartinJohns]

@electricessence: As a workaround you could use a custom type-guard function with function overloading:

function isTypeOf(value: any, type: TypeOfValue.Boolean): value is boolean;
function isTypeOf(value: any, type: TypeOfValue.Number): value is number;
function isTypeOf(value: any, type: TypeOfValue.String): value is string;
function isTypeOf(value: any, type: TypeOfValue.Symbol): value is symbol;
function isTypeOf(value: any, type: TypeOfValue.Object): value is object;
function isTypeOf(value: any, type: TypeOfValue.Undefined): value is undefined;
function isTypeOf(value: any, type: TypeOfValue.Function): value is Function;
function isTypeOf(value: any, type: TypeOfValue) {
    return typeof value === type;
}

if (isTypeOf(x, TypeOfValue.String)) {
    // x is inferred to be a string here.
} else if (isTypeOf(x, TypeOfValue.Number)) {
    // x is inferred to be a boolean here.
}

[electricessence]

@MartinJohns yeah I know that I can use custom type guards but that's what I'm trying to get away from when it's unnecessary. I have had success with building a virtual enum by declaring exported constants each as the string literal types. But I was hoping for the same behavior from enums.

[electricessence]

What I like about the string enum types is that they function as both a type and as set of constants.

[RyanCavanaugh]

String enums are intentionally opaque; see #17690. The namespace alternate pattern is available if you want non-opaque literal values.

[electricessence]

@RyanCavanaugh ok. I actually was using that pattern before. Thought it was more elegant to use enums.