What is the "never" type in TypeScript?

In TypeScript, the 'never' type represents values that never occur. This type is primarily used in two scenarios: one is in functions to indicate that the function never returns a value, meaning it throws an error or enters an infinite loop before completion; the other is for types that cannot have instances.

Function Applications:

Functions that Throw Errors: In TypeScript, when a function throws an error and does not return any value, its return type can be marked as never. For example:

typescript
function throwError(errorMsg: string): never {
    throw new Error(errorMsg);
}

Here, the throwError function takes a string as a parameter and throws an error, so the function does not return normally, hence its type is never.

Functions that Enter an Infinite Loop: Another example is a function that enters an infinite loop, meaning the function also does not return any value:

typescript
function infiniteLoop(): never {
    while (true) {
    }
}

This infiniteLoop function never terminates, so it also uses the never type.

Applications in the Type System:

In TypeScript's type system, the never type is also used to represent types that cannot have instances. For example:

typescript
type Empty = never[];

Here, a type Empty is defined, which is an array that can only contain elements of the never type. Since the never type represents values that never exist, such an array cannot have any actual elements.

Summary:

The never type is an advanced type feature in TypeScript. It not only helps in handling exceptions or special operations within functions but also in the type system for dealing with types that logically cannot exist. By using the never type, TypeScript can perform more effective type checking and avoid potential errors.