Why Exhaustive pattern matching in Typescript? - Purpose & Use Cases

The Big Idea

What if your program silently ignores some cases and breaks later? Exhaustive pattern matching stops that before it starts!

The Scenario

Imagine you have a list of different shapes like circles, squares, and triangles, and you want to write code that does something special for each shape. Without exhaustive pattern matching, you might forget to handle one shape, and your program could behave strangely or crash.

The Problem

Manually checking each shape type with many if-else statements is slow and easy to mess up. You might miss a shape type or write duplicate code. This makes your program buggy and hard to fix.

The Solution

Exhaustive pattern matching forces you to cover every possible case. It helps your code check all shape types clearly and safely. If you forget one, the program warns you right away, so you never miss a case.

Before vs After

✗ Before

if (shape.type === 'circle') { /* handle circle */ } else if (shape.type === 'square') { /* handle square */ } // forgot triangle!

✓ After

match(shape) { case { type: 'circle' }: /* handle circle */; case { type: 'square' }: /* handle square */; case { type: 'triangle' }: /* handle triangle */; }

What It Enables

It makes your code safer and easier to maintain by ensuring every possible case is handled.

Real Life Example

When building a drawing app, you can use exhaustive pattern matching to make sure every shape type is drawn correctly, so users never see missing or broken shapes.

Key Takeaways

Manual checks can miss cases and cause bugs.

Exhaustive pattern matching forces handling all cases.

This leads to safer, clearer, and more reliable code.

Practice

1.

What is the main purpose of exhaustive pattern matching in TypeScript?

easy

A. To allow dynamic typing in TypeScript

B. To ensure all possible cases of a union type are handled

C. To improve runtime performance by skipping cases

D. To automatically generate switch cases

Solution

1. Step 1: Understand union types and pattern matching

   Exhaustive pattern matching ensures every variant of a union type is explicitly handled in code.

2. Step 2: Identify the purpose of exhaustive checks

   This prevents missing cases that could cause bugs or unexpected behavior.

3. Final Answer:

   To ensure all possible cases of a union type are handled -> Option B

4. Quick Check:

   Exhaustive pattern matching = handle all cases [OK]

Hint: Exhaustive means covering every case without missing any [OK]

Common Mistakes:

• Thinking it improves runtime speed
• Confusing with dynamic typing
• Assuming it auto-generates code

2.

Which of the following switch statements correctly uses exhaustive pattern matching for this union type?

type Shape = 'circle' | 'square' | 'triangle';

easy

A. switch(shape) { case 'circle': break; case 'square': break; case 'triangle': break; }

B. switch(shape) { case 'circle': break; case 'square': break; default: break; }

C. switch(shape) { case 'circle': break; case 'square': break; case 'triangle': break; default: const _exhaustiveCheck: never = shape; }

D. switch(shape) { case 'circle': break; case 'square': break; case 'triangle': break; default: console.log('unknown'); }

Solution

1. Step 1: Check all cases are handled

   Cases for 'circle', 'square', and 'triangle' are present in options B, C, and D.

2. Step 2: Verify exhaustive check with never type

   Only switch(shape) { case 'circle': break; case 'square': break; case 'triangle': break; default: const _exhaustiveCheck: never = shape; } uses default with const _exhaustiveCheck: never = shape; to enforce exhaustiveness.

3. Final Answer:

   switch with all cases and default assigning to never -> Option C

4. Quick Check:

   Exhaustive switch = all cases + never default [OK]

Hint: Look for default assigning to never for exhaustiveness [OK]

Common Mistakes:

• Omitting the default case with never assignment
• Using default without never type
• Missing one of the union cases

3.

What will be the output of this TypeScript code?

type Status = 'success' | 'error';
function handleStatus(status: Status) {
  switch (status) {
    case 'success':
      return 'Yay!';
    case 'error':
      return 'Oops!';
    default:
      const _exhaustiveCheck: never = status;
      return _exhaustiveCheck;
  }
}
console.log(handleStatus('success'));

medium

A. Compilation error

B. "Oops!"

C. Runtime error

D. "Yay!"

Solution

1. Step 1: Analyze the switch cases for 'success'

   The input is 'success', so the first case matches and returns 'Yay!'.

2. Step 2: Check the default case usage

   The default case is unreachable here but ensures exhaustiveness by assigning to never.

3. Final Answer:

   "Yay!" -> Option D

4. Quick Check:

   Input 'success' returns 'Yay!' [OK]

Hint: Match input case to return value directly [OK]

Common Mistakes:

• Thinking default case runs for valid inputs
• Expecting runtime or compile errors
• Confusing return values for cases

4.

Identify the error in this exhaustive pattern matching code:

type Direction = 'up' | 'down' | 'left' | 'right';
function move(dir: Direction) {
  switch (dir) {
    case 'up':
      return 'Moving up';
    case 'down':
      return 'Moving down';
    case 'left':
      return 'Moving left';
    default:
      const _exhaustiveCheck: never = dir;
      return _exhaustiveCheck;
  }
}

medium

A. Missing case for 'right' in the switch statement

B. Default case should not assign to never

C. Function should return void instead of string

D. Switch statement syntax is incorrect

Solution

1. Step 1: Check all union cases in switch

   Cases for 'up', 'down', and 'left' exist, but 'right' is missing.

2. Step 2: Understand the role of default with never

   The default assigns to never to catch unhandled cases, so missing 'right' causes a compile error.

3. Final Answer:

   Missing case for 'right' in the switch statement -> Option A

4. Quick Check:

   All union cases must be handled explicitly [OK]

Hint: Check if all union members have cases before default [OK]

Common Mistakes:

• Assuming default covers missing cases silently
• Misusing never assignment in default
• Ignoring missing union members

5.

Given this nested union type, which switch structure correctly uses exhaustive pattern matching to handle all cases?

type Animal = { type: 'dog'; breed: 'bulldog' | 'beagle' } | { type: 'cat'; color: 'black' | 'white' };

hard

A. switch(animal.type) {
case 'dog':
switch(animal.breed) {
case 'bulldog': break;
case 'beagle': break;
default: const _exhaustiveCheck: never = animal.breed;
}
break;
case 'cat':
switch(animal.color) {
case 'black': break;
case 'white': break;
default: const _exhaustiveCheck: never = animal.color;
}
break;
default: const _exhaustiveCheck: never = animal.type;
}

B. switch(animal.type) {
case 'dog':
if(animal.breed === 'bulldog' || animal.breed === 'beagle') break;
break;
case 'cat':
if(animal.color === 'black' || animal.color === 'white') break;
break;
default: const _exhaustiveCheck: never = animal.type;
}

C. switch(animal.type) {
case 'dog':
case 'cat':
break;
default: const _exhaustiveCheck: never = animal.type;
}

D. switch(animal.type) {
case 'dog':
switch(animal.breed) {
case 'bulldog': break;
default: const _exhaustiveCheck: never = animal.breed;
}
break;
case 'cat':
switch(animal.color) {
case 'black': break;
case 'white': break;
}
break;
default: const _exhaustiveCheck: never = animal.type;
}

Solution

1. Step 1: Check outer switch covers all 'type' cases

   Cases for 'dog' and 'cat' are present with default assigning to never.

2. Step 2: Check inner switches cover all nested union cases

   For 'dog', both 'bulldog' and 'beagle' are handled with default never; for 'cat', both 'black' and 'white' are handled similarly.

3. Step 3: Verify no missing cases in nested switches

   All nested union members are covered with exhaustive checks.

4. Final Answer:

   Nested switches with all cases and never defaults for both levels -> Option A

5. Quick Check:

   Nested exhaustive switches = all cases + never defaults [OK]

Hint: Use nested switches with never defaults for each union level [OK]

Common Mistakes:

• Skipping some nested union cases
• Using if conditions without exhaustive checks
• Missing never assignment in inner switches