When working with enums in Rust, I realized that switch statements in TypeScript are not exhaustive.

This means that the compiler doesn't warn you if you forget to handle a case in a switch statement. This is a problem because it can lead to bugs that are difficult to track down.

As you may know, I'm a big fan of type safety. I find it very concerning that forgetting to handle an enum variant doesn't result in a compiler error.

In this post, I'll show you how to make your switch statements exhaustive so that you can avoid these bugs.

What is an Exhaustive Switch Statement?

An exhaustive switch statement is one that handles all possible cases. For example, if you have an enum with three variants, your switch statement should have three cases: one for each variant.

Here's an example of an exhaustive switch statement in TypeScript:

enum Direction {
  Up,
  Down,
  Left,
  Right,
}

function move(direction: Direction) {
  switch (direction) {
    case Direction.Up:
      console.log('Moving up');
      break;
    case Direction.Down:
      console.log('Moving down');
      break;
    case Direction.Left:
      console.log('Moving left');
      break;
    case Direction.Right:
      console.log('Moving right');
      break;
  }
}

As you can see, this switch statement handles all possible cases.

Unfortunately, if you add a new variant to the Direction enum, the compiler won't warn you that you need to add a new case to the switch statement.

Let's see what happens if we add a new variant to the Direction enum:

enum Direction {
  Up,
  Down,
  Left,
  Right,
  Forward, // new variant
}

function move(direction: Direction) {
  switch (direction) {
    case Direction.Up:
      console.log('Moving up');
      break;
    case Direction.Down:
      console.log('Moving down');
      break;
    case Direction.Left:
      console.log('Moving left');
      break;
    case Direction.Right:
      console.log('Moving right');
      break;
  }
}

// call `move()` with the new variant
move(Direction.Forward);

This code compiles without any errors or warnings, but it's not exhaustive because it doesn't handle the Forward variant, therefore it's not very type safe.

Why is an exhaustive switch statement important?

An exhaustive switch statement is crucial as it aids in avoiding elusive bugs.

It is very easy to forget to handle a case in a switch statement, especially if you are working on a large codebase where there are many places where a particular enum is used (giving you many switch statements to update).

As a result, you can end up with bugs, which won't show up until you run your code and try to use the new variant.

Most often, this becomes an issue during code refactoring or when a new variant is added to an enum.

How to make your switch statements exhaustive

There are two ways to make your switch statements exhaustive:

1. Use the default case
2. Combine default case with the never type

Let's take a look at each of these options.

Use the default case

The easiest way to make your switch statements exhaustive is to use the default case. This makes your switch statement handle all possible cases that aren't explicitly handled by another case.

Here's an example of using the default case to make your switch statement exhaustive:

enum Direction {
  Up,
  Down,
  Left,
  Right,
}

function move(direction: Direction) {
  switch (direction) {
    case Direction.Up:
      console.log('Moving up');
      break;
    case Direction.Down:
      console.log('Moving down');
      break;
    case Direction.Left:
      console.log('Moving left');
      break;
    case Direction.Right:
      console.log('Moving right');
      break;
    default:
      // handle all other cases
      console.log('Moving in an unknown direction');
      break;
  }
}

This code will work "as expected" if you add a new variant to the Direction enum. However, it's still easy to forget to handle the new variant when it requires special handling, especially for a developer who just started working with a codebase.

It also may seem redundant to have a default case when you already have a switch statement that handles all possible cases and it might be tempting to remove it.

We can improve this code by using the never type to make compiler errors when we forget to handle a case.

Combine default case with the never type

The second way to make your switch statements exhaustive is to use the default case with a special type called never. It is used to make sure that you've handled all possible cases in a switch statement. If you forget to handle a case, the compiler will give you an error.

Let's take a look at an example:

enum Direction {
  Up,
  Down,
  Left,
  Right,
  Forward, // new variant
}

function move(direction: Direction) {
  switch (direction) {
    case Direction.Up:
      console.log('Moving up');
      break;
    case Direction.Down:
      console.log('Moving down');
      break;
    case Direction.Left:
      console.log('Moving left');
      break;
    case Direction.Right:
      console.log('Moving right');
      break;
    default:
      // this line will cause a compiler error
      // as `Direction.Forward` is not assignable to `never`
      const _exhaustiveCheck: never = direction;
      break;
  }
}

This code will cause a compiler error if you forget to handle a case in your switch statement.

Here's what the compiler error looks like:

Type 'Direction' is not assignable to type 'never'. (2322)

This is because the never type is a special type that represents the type of values that never occur. In other words, it's a type that can never be assigned a value.

In this case, our switch will check whether passed direction is one of the explicitly handled cases (Up, Down, Left and Right). If it's not, then the default case will be executed, which will assign the passed direction to the _exhaustiveCheck variable.

As there is one more variant (Forward) that is not handled by the switch statement, the compiler will throw an error because the _exhaustiveCheck variable is of type never and it can't be assigned a value of type Direction.

If we add a new case to the switch statement, the compiler error will go away, since the switch statement will handle all possible cases. This makes direction to be of type never and the _exhaustiveCheck variable will be of type never as well.

The final code will look like this:

enum Direction {
  Up,
  Down,
  Left,
  Right,
  Forward, // new variant
}

function move(direction: Direction) {
  switch (direction) {
    case Direction.Up:
      console.log('Moving up');
      break;
    case Direction.Down:
      console.log('Moving down');
      break;
    case Direction.Left:
      console.log('Moving left');
      break;
    case Direction.Right:
      console.log('Moving right');
      break;
    case Direction.Forward:
      console.log('Moving forward');
      break;
    default:
      const _exhaustiveCheck: never = direction; // no more errors!
      break;
  }
}

Conclusion

When working with switch statements, it's important to make sure that you've handled all possible cases. If you value type safety, you can use the never type to make sure that you've handled all possible cases in your switch statements. This not only helps you avoid runtime errors but also makes your code more predictable and easier to maintain.

Note on exhaustiveness checking

The "hack" with the never type is not the most beautiful solution, but it works. It was the only way to make switch statements exhaustive in TypeScript I was able to find. If you know a better way to make switch statements exhaustive, please let me know!

I hope that in the future TypeScript will provide a better way to make switch statements exhaustive.