Exploring the concept of the never type in TypeScript 2

Question

Exploring the concept of the never type in TypeScript 2

Exploring the latest features in TypeScript 2.0, I came across the never type. It appears to be a clever method for defining the type of functions that do not have a return value.

If I understand correctly, the never type can be assigned to any other type, but only never itself can be assigned to never. While experimenting with a simple test in VS Code, I encountered the following scenario:

function generateError(){
    throw new Error("oops");
}
function do(option: "opt1" | "opt2"){
    if(option === "opt1") return true;
    if(option === "opt2 ) return false;
    generateError();
}
let res = do("blah");

What type is expected for res? The compiler indicates string | undefined, which does make sense although I initially anticipated just string. I wonder about the necessity of introducing a new type solely for functions that never return. Is this concept truly essential? Or is it primarily a tool for the compiler to enhance flow analysis?

typescript typescript2.0

Answer 1

Answer №1

It is crucial to note that this specific section should not be accessible. Take, for example, the following code snippet:

function do(): never {
    while (true) {}
}

This code contains an infinite loop, which we want to avoid iterating indefinitely.

However, a pertinent question arises: how can this concept be beneficial to us? One possible application is in defining more advanced types to specify what they are not.

For instance, let's define our own NonNullable type:

type NonNullable<T> = T extends null | undefined ? never : T;

In this scenario, we check if T is either null or undefined. If it is, we indicate that it should never occur. Subsequently, when utilizing this type:

let value: NonNullable<string>;
value = "Test";
value = null; // error

Answer 2

It is crucial to note that this specific section should not be accessible. Take, for example, the following code snippet:

function do(): never {
    while (true) {}
}

This code contains an infinite loop, which we want to avoid iterating indefinitely.

However, a pertinent question arises: how can this concept be beneficial to us? One possible application is in defining more advanced types to specify what they are not.

For instance, let's define our own NonNullable type:

type NonNullable<T> = T extends null | undefined ? never : T;

In this scenario, we check if T is either null or undefined. If it is, we indicate that it should never occur. Subsequently, when utilizing this type:

let value: NonNullable<string>;
value = "Test";
value = null; // error

Answer 3

Answer №2

By utilizing the never keyword, you can guarantee that no function contract goes unnoticed.

function eternal(): never {
    while (true) {
        break; // An error occurs if attempting to exit this function.
    }
}

enum Options {
    X,
    Y
}

function decide(option: Options) {
    switch (option) {
        case Options.X: return "X";
    }

    let y: never = option; // Generates an error as Y is not accounted for in the switch statement.
}

Answer 4

By utilizing the never keyword, you can guarantee that no function contract goes unnoticed.

function eternal(): never {
    while (true) {
        break; // An error occurs if attempting to exit this function.
    }
}

enum Options {
    X,
    Y
}

function decide(option: Options) {
    switch (option) {
        case Options.X: return "X";
    }

    let y: never = option; // Generates an error as Y is not accounted for in the switch statement.
}

Answer 5

Answer №3

Functions that do not return and functions that may throw exceptions are different concepts.

For instance:

function foo(option: "opt1" | "opt2"): string | undefined {
  if (option === "opt1") return true;
  if (option === "opt2") return false;
  throw new Error("unknown option");
}

function bar(option: "opt1" | "opt2"): never {
  while (true) {
    doOption(option);
  }
}

The first function might return a value, so its return type cannot be never. If it can return something, then it is not considered as never returning.

The second function will truly never return anything. It doesn't matter what conditions you put in, it will not return a value or even undefined.

There are cases where functions seem like the second one but actually belong to the first category, especially when exceptions are thrown or when using process.exit in node.js, which terminates the process.

Answer 6

Functions that do not return and functions that may throw exceptions are different concepts.

For instance:

function foo(option: "opt1" | "opt2"): string | undefined {
  if (option === "opt1") return true;
  if (option === "opt2") return false;
  throw new Error("unknown option");
}

function bar(option: "opt1" | "opt2"): never {
  while (true) {
    doOption(option);
  }
}

The first function might return a value, so its return type cannot be never. If it can return something, then it is not considered as never returning.

The second function will truly never return anything. It doesn't matter what conditions you put in, it will not return a value or even undefined.

There are cases where functions seem like the second one but actually belong to the first category, especially when exceptions are thrown or when using process.exit in node.js, which terminates the process.

Exploring the concept of the never type in TypeScript 2

Answer №1

Answer №2

Answer №3

Similar questions

Consolidating repeated data objects found in the response

Troubleshooting problem with fetching data from Angular API

Adapting imports in Typescript for seamless npm distribution

Encountering issues with managing CometD channels within Angular 2

Exploring the functionality of multiple checkboxes in Next.js 14, the zod library, shadcn/ui components, and react-hook

I'm having trouble configuring the header in my Node/Express route

Error in TypeScript: Objects can only specify properties that are known, and 'state' is not found in type 'Partial<Path>'

Using [file_id] as a dynamic parameter in nextjs pages

Is there a feature in VS Code that can automatically update import paths for JavaScript and TypeScript files when they are renamed or

What is the correct way to interpret a JSON file using TypeScript?

Declaring TypeScript functions with variable numbers of parameters

Exploring ways to exclude a column in a TypeORM entity while also providing the flexibility to make it optional for retrieval using the Find method

Is it possible to integrate TypeScript 5.0 decorators into React components?

Web application experiences freezing issues when utilizing specific components in certain situations

Application built with Electron and Typescript encounters module-related crash

The function 'makeDecorator' does not support function calls when being accessed

Utilize a function to wrap the setup and teardown code in Jest

When clicking initially, the default input value in an Angular 2 form does not get set

Creating instance methods in a TypeScript object can be accomplished by defining the methods within the object's class definition. When the object is

An optional field has been identified as ng-invalid