Never type and unreachable code in Typescript - Mini Project: Build & Apply

Never type and unreachable code

📖 Scenario: You are writing a TypeScript program that uses the never type to handle impossible cases. This helps catch errors early and avoid unreachable code.

🎯 Goal: Build a TypeScript function that uses the never type to handle unexpected input and demonstrate unreachable code detection.

📋 What You'll Learn

Create a function with a switch statement on a string parameter

Add a never type function to handle impossible cases

Use the never type function in the switch default case

Print the result of calling the function with valid and invalid inputs

💡 Why This Matters

🌍 Real World

Using the <code>never</code> type helps developers catch bugs early by ensuring all possible cases are handled, especially in complex decision logic.

💼 Career

Understanding unreachable code and the <code>never</code> type is important for writing robust TypeScript code in professional software development.

1

Create a function with a switch statement

Create a function called getColorCode that takes a parameter color of type string. Inside the function, write a switch statement on color with cases for 'red', 'green', and 'blue'. Return '#FF0000' for 'red', '#00FF00' for 'green', and '#0000FF' for 'blue'.

Typescript

function getColorCode(color: string): string {
    // Your code here
}

Hint

Use a switch statement with case labels for each color and return the matching hex code string.

2

Add a never type function for impossible cases

Create a function called assertNever that takes a parameter value of type never and throws an Error with the message 'Unexpected value: ' + value.

Typescript

function getColorCode(color: string): string {
    switch (color) {
        case 'red':
            return '#FF0000';
        case 'green':
            return '#00FF00';
        case 'blue':
            return '#0000FF';
        default:
            throw new Error('Invalid color');
    }
}

// Your code here

Hint

The assertNever function should accept only never type and throw an error with the unexpected value.

3

Use the never type function in the switch default case

Modify the getColorCode function to add a default case in the switch statement. In the default case, call assertNever(color as never) to handle unreachable code.

Typescript

function getColorCode(color: string): string {
    switch (color) {
        case 'red':
            return '#FF0000';
        case 'green':
            return '#00FF00';
        case 'blue':
            return '#0000FF';
        // Your code here
    }
}

function assertNever(value: never): never {
    throw new Error('Unexpected value: ' + value);
}

Hint

Add a default case that calls assertNever with color as never to catch unreachable cases.

4

Print the result of calling the function

Write two console.log statements. The first calls getColorCode('red') and prints the result. The second calls getColorCode('yellow') inside a try block and catches the error to print 'Error caught: ' + error.message.

Typescript

function getColorCode(color: string): string {
    switch (color) {
        case 'red':
            return '#FF0000';
        case 'green':
            return '#00FF00';
        case 'blue':
            return '#0000FF';
        default:
            return assertNever(color as never);
    }
}

function assertNever(value: never): never {
    throw new Error('Unexpected value: ' + value);
}

// Your code here

Hint

Use console.log to print the color code for 'red'. Use a try-catch block to catch and print the error message for 'yellow'.

Practice

1. What does the never type represent in TypeScript?

easy

A. A variable that can hold any type of value.

B. A type that represents optional values.

C. A function that returns null or undefined.

D. A function that never returns normally, like one that always throws an error or loops forever.

Solution

1. Step 1: Understand the never type meaning

   The never type is used for functions or expressions that never complete normally, such as those that throw errors or run infinite loops.

2. Step 2: Compare with other types

   Other options describe common types like any, null, or optional, which are different from never.

3. Final Answer:

   A function that never returns normally, like one that always throws an error or loops forever. -> Option D

4. Quick Check:

   never means no normal return [OK]

Hint: Never means function never finishes normally [OK]

Common Mistakes:

• Confusing never with void or any
• Thinking never means optional or nullable
• Assuming never is a value type

2. Which of the following is the correct syntax for a function that returns never in TypeScript?

easy

A. function fail(): never { throw new Error('Fail'); }

B. function fail(): void { return; }

C. function fail(): never { return null; }

D. function fail(): string { throw new Error('Fail'); }

Solution

1. Step 1: Check function return type and body

   A function returning never must not return normally. Throwing an error fits this.

2. Step 2: Validate each option

   function fail(): never { throw new Error('Fail'); } throws an error, so it never returns normally. function fail(): void { return; } returns void normally. function fail(): never { return null; } tries to return null, which is invalid for never. function fail(): string { throw new Error('Fail'); } returns string but throws, so return type mismatches.

3. Final Answer:

   function fail(): never { throw new Error('Fail'); } -> Option A

4. Quick Check:

   Throw error matches never return [OK]

Hint: Throw error to return never type correctly [OK]

Common Mistakes:

• Returning a value in a never function
• Using void instead of never
• Returning null or undefined in never

3. What will be the output of this TypeScript code?

function check(value: string | number) {
  switch (typeof value) {
    case 'string':
      return 'string';
    case 'number':
      return 'number';
    default:
      const _exhaustiveCheck: never = value;
      return _exhaustiveCheck;
  }
}
console.log(check(42));

medium

A. 'string'

B. 'number'

C. Compilation error due to unreachable code

D. Runtime error

Solution

1. Step 1: Analyze the switch cases

   The function handles 'string' and 'number' types explicitly, so the default case is unreachable for these inputs.

2. Step 2: Check the call and output

   Calling check(42) matches the 'number' case, so it returns 'number'. The default case with never is never reached.

3. Final Answer:

   'number' -> Option B

4. Quick Check:

   Handled all cases, returns 'number' [OK]

Hint: Check switch covers all types, default never runs [OK]

Common Mistakes:

• Thinking default case runs for known types
• Confusing never with runtime errors
• Expecting compilation error for unreachable default

4. Identify the error in this TypeScript code snippet:

function assertNever(x: never): never {
  throw new Error('Unexpected value: ' + x);
}

function process(value: string | number) {
  if (typeof value === 'string') {
    return 'string';
  } else if (typeof value === 'number') {
    return 'number';
  } else {
    return assertNever(value);
  }
}

medium

A. Error because assertNever should return void not never.

B. Error because assertNever is called with a non-never type.

C. No error; code is correct and safe.

D. Error because value can never be string | number.

Solution

1. Step 1: Understand the function purpose

   assertNever is used to catch unexpected values at compile time by requiring a never type.

2. Step 2: Analyze the process function

   All possible types string and number are handled. The else branch is unreachable, so value is never there, making the call valid.

3. Final Answer:

   No error; code is correct and safe. -> Option C

4. Quick Check:

   Unreachable else means value is never [OK]

Hint: Else unreachable means value is never type [OK]

Common Mistakes:

• Thinking assertNever is called with string or number
• Confusing never return with void
• Assuming else branch always runs

5. Given this TypeScript code, what is the best way to ensure all cases are handled and catch missing cases at compile time?

type Shape = { kind: 'circle', radius: number } | { kind: 'square', size: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    // Missing case for 'square'
  }
}

hard

A. Add a default case that calls a function accepting never to catch unhandled cases.

B. Ignore missing cases; TypeScript will warn automatically.

C. Add a default case that returns 0 without checks.

D. Use any type for shape to avoid errors.

Solution

1. Step 1: Identify missing case problem

   The 'square' case is missing, so the switch is not exhaustive.

2. Step 2: Use never type to catch missing cases

   Adding a default case that calls a function requiring never forces TypeScript to check exhaustiveness and report missing cases.

3. Final Answer:

   Add a default case that calls a function accepting never to catch unhandled cases. -> Option A

4. Quick Check:

   Use never in default to enforce exhaustiveness [OK]

Hint: Use default with never to catch missing cases [OK]

Common Mistakes:

• Assuming TypeScript warns without default never
• Returning default values silently
• Using any to bypass type safety