narrowing doesn't work for literal strings in switch when united with unconstrained string

nightly build, August 18, 2016

function useA(value: 'a'): void { }
function useB(value: 'b'): void { }
function useSomethingElse(value: string): void { }
declare var kind: string | 'a' | 'b';
switch (kind) {
    case 'a': useA(kind); break; // expected kind to be 'a', actual 'a' | string
    case 'b': useB(kind); break;
    default: useSomethingElse(kind); break;
}

Side question: what was your intent declaring something string | 'a' | 'b' ?

example1: DB guys introduced a new possible value to a set of well-known values, without letting anyone know, this new case has to be treated separately as a failure/default case/you name it

example2: this one is lengthy, gradual open-ended narrowing via composing resolving functions

SomeStuff is a union of One and Another why not to take advantage of their resolver functions

type One = 'a' | 'b';
interface ViaOne<r> {
   caseOfA: (value: 'a') => r;
   caseOfB: (value: 'b') => r;
}
function viaOne<r>(kind: One | string, via: ViaOne<r>) : Optional<r> {
   switch (kind) {
       case 'a': return someFrom(via.caseOfA(kind));
       case 'b': return someFrom(via.caseOfB(kind));
       default: return none;
   }
}
type Another = 'c' | 'd';
interface ViaAnother<r> {
    caseOfC: (value: 'c') => r;
    caseOfD: (value: 'd') => r;
}
function viaAnother<r>(kind: Another | string, via: ViaAnother<r>): Optional<r> {
   switch (kind) {
       case 'c': return someFrom(via.caseOfA(kind));
       case 'd': return someFrom(via.caseOfB(kind));
       default: return none;
   }
}

type CrazyStuff = One | Another;
interface ViaCrazyStuff<r> extends ViaOne<r>, ViaAnother<r> {}

function viaCrazyStuff<r>(value: CrazyStuff, via: ViaCrazyStuff<r>): Optional<r> {
   const tryOne = viaOne(value, via);
   if (isSome(tryOne)) {
       return tryOne;
   } else {
       return viaAnother(value, via);
   }
}

This is working as intended, so I'm changing the label to a suggestion. We currently only narrow in a switch statement when the type of the switch expression is a union of unit types. In your example, there's really no difference between the type string and string | 'a' | 'b'.

fyi, there is a workaround using T extends string rather than plain string

function useA(value: 'a'): void { }
function useB(value: 'b'): void { }
function useSomethingElse(value: string): void { }

function test<c extends string>(kind: 'a' | 'b' | c) {
    switch (kind) {
        case 'a': useA(kind); break;
        case 'b': useB(kind); break;
        default: useSomethingElse(kind);
    }
}

Anders Hejlsberg (@ahejlsberg)

Anders Hejlsberg (@ahejlsberg) why wouldn't we narrow whenever a literal value matches a literal in a union?

Navigation Menu

Repository navigation

narrowing doesn't work for literal strings in switch when united with unconstrained string #10417

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

narrowing doesn't work for literal strings in switch when united with unconstrained string #10417

Description

Activity

RyanCavanaugh commented on Aug 18, 2016

zpdDG4gta8XKpMCd commented on Aug 18, 2016

ahejlsberg commented on Aug 18, 2016

zpdDG4gta8XKpMCd commented on Aug 19, 2016

RyanCavanaugh commented on Aug 19, 2016

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions