嵌套的switch语句可以在TypeScript中穷举吗？

Question

It looks like the following code doesn't type check in TypeScript.

interface A {
    type: 'a',
    number: Number
}

interface B {
    type: 'b',
    number: Number
}

type Letter = A | B

interface One {
    type: 'one'
}

interface Two {
    type: 'two'
}

type Number = One | Two;


function we(letter: Letter): boolean { // claims boolean isn't always returned
    switch (letter.type) {
        case 'a':
            return true;

        case 'b':
            const number = letter.number;
            switch (number.type) {
                case 'one':
                    return true;
                case 'two':
                    return true;
            }
    }
}

I can add a default to the inner switch to get it working but I'm surprised that I need to given that a flat switch works just fine. What exactly is going on here?

Answer 1

The problem here is that you haven't handled the case where the data isn't what you declared that it would be. Maybe somewhere there could be casts to any and then assigning letter.type='c' . Or for that matter just call it like this:

we({type: 'c'} as any as Letter);

The double cast ensures you get no compiler warnings, but that isn't a case you've allowed for in the function.

Here's one way to sort it:

function exhaustiveCheck(value: never): never {
  throw(new Error('switch was not exhaustive'));
}

function we(letter: Letter): boolean {
    switch (letter.type) {
        case 'a':
            return true;

        case 'b':
            const number = letter.number;
            switch (number.type) {
                case 'one':
                    return true;
                // case 'two':
                //     return true;
                default:
                  return exhaustiveCheck(number);
            }
        default: {
          return exhaustiveCheck(letter);
        }
    }
}

This ensures that at runtime, if you get data that wasn't as the type system described it will be checked and throw an error, but at compile time it also ensures you have exhaustively handled all of the cases.

As I wrote the code above, you get a compile time error for the call to exhaustiveCheck(number) , uncomment the two lines above it and the error will go away. The second call to exhaustiveCheck(letter) is accepted because in the default case we have already covered both of the types A and B so the only case remaining is that letter has the type never : that means so far as the type system is concerned it should never happen even though at runtime it possible could happen.