Never type and unreachable code in Typescript - Step-by-Step Execution

Concept Flow - Never type and unreachable code

Start function

↓

Check all cases

↓

If no return or throw

↓

Return never type or unreachable

↓

End function

The function checks all cases: either returns a value or calls a never-returning function that throws an error, so code after is unreachable.

Execution Sample

Typescript

function fail(message: string): never {
  throw new Error(message);
}

function example(x: number | string) {
  if (typeof x === 'number') return x;
  fail('Not a number');
}

This code shows a function that never returns normally (throws error) and how unreachable code is handled.

Execution Table

Step	Code Line	Action	Evaluation	Result
1	function example called with x=42	Check type of x	typeof 42 === 'number'	true
2	if branch taken	Return x	return 42	42
3	function example called with x='hello'	Check type of x	typeof 'hello' === 'number'	false
4	else branch	Call fail('Not a number')	throw new Error('Not a number')	Exception thrown
5	Code after fail call	Unreachable	No execution	never reached

💡 Execution stops either by returning a value or throwing an error (never returns).

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
x	undefined	42	42	'hello'	'hello'
return value	none	42	42	none	none (throws)

Key Moments - 2 Insights

Why is the code after the fail() call unreachable?

Because fail() throws an error and never returns, so the program stops there. See execution_table row 5 where code after fail() is never executed.

What does the never type mean in TypeScript?

It means the function never returns normally, either it throws or loops forever. In the example, fail() has return type never because it always throws (execution_table row 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the result when example(42) is called?

A 42

B Exception thrown

C undefined

D never

💡 Hint

Check execution_table row 2 where example returns 42.

At which step does the function throw an error?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

See execution_table row 4 where fail() throws an error.

If fail() did not throw an error, what would happen to the code after it?

A The function would return never type

B It would still be unreachable

C It would be reachable and executed

D The function would throw an error anyway

💡 Hint

Refer to key_moments about unreachable code after fail() call.

Concept Snapshot

Never type means a function never returns normally (throws or loops forever).
Code after a never-returning call is unreachable.
TypeScript uses never type to catch unreachable code.
Example: function fail() throws error and returns never.
Functions handling all cases can use never to signal no normal return.

Full Transcript

This example shows how TypeScript's never type works. The function fail() throws an error and never returns normally. When example() calls fail(), the code after fail() is unreachable. The execution table traces calls with x as number or string. When x is number, example returns it. When x is string, fail() throws an error, stopping execution. The never type helps TypeScript know that code after fail() won't run. This prevents unreachable code bugs and helps with type safety.