Throwing in a ternary/conditional operator expression in Typescript 2

Question

Throwing in a ternary/conditional operator expression in Typescript 2

When attempting to compile the following code:

const value = "20"
const x : string | never = "10" === value ? throw Error("bad things") : "hello"

An error is encountered on throw - expression expected. One way to resolve this issue is by using an inline method invoked in place, although it may not look very clean. (

(() => {throw Error("bad things")})()

)

Why is it not acceptable to use throw in a branch of the ternary operator? Are there alternative syntax options that could work, or perhaps certain compile settings that I am overlooking?

It also seems that throw does not function properly without curly brackets in the function body, as shown in the workaround, (

(() => throw Error("bad things"))()

).

exception typescript conditional-operator

Answer 1

Answer №1

This matter is still pending resolution.

https://github.com/microsoft/TypeScript/issues/18535

According to the matter at hand, actions regarding its implementation will not commence until ECMA TC39 comes to a decision.

Answer 2

This matter is still pending resolution.

https://github.com/microsoft/TypeScript/issues/18535

According to the matter at hand, actions regarding its implementation will not commence until ECMA TC39 comes to a decision.

Answer 3

Answer №2

It's an interesting quirk in the syntax of this particular language.

The use of throw ex can be seen as producing a type of never, given that never represents functions that do not return, which accurately describes what happens when you throw. In programming languages with a concept known as a bottom type (which is the technical term for what never signifies - it's more than just a peculiar keyword).

Contrary to statements like for (let x of ...), which clearly do not return any value, throw ex can be interpreted as returning never.

Answer 4

It's an interesting quirk in the syntax of this particular language.

The use of throw ex can be seen as producing a type of never, given that never represents functions that do not return, which accurately describes what happens when you throw. In programming languages with a concept known as a bottom type (which is the technical term for what never signifies - it's more than just a peculiar keyword).

Contrary to statements like for (let x of ...), which clearly do not return any value, throw ex can be interpreted as returning never.

Answer 5

Answer №3

When it comes to constructing languages, there is a distinction between statements and expressions. For example, assigning a value to x is a statement or operation rather than a value or expression.

Attempting something like the following won't work for the same reason:

const x : string | never = "10" === value ? for(var i in myArray) { /* do stuff */ } : "hello".

This goes against the rules of the language, although you may find ways to work around it using self-evaluation functions that theoretically evaluate as an expression.

To understand the difference between statements and expressions better, refer to this question.

In TypeScript, the never keyword is a peculiar type associated with control flow analysis. It prevents treating statements as expressions. If you prefer not to use immediately invoked function expressions, consider using a regular function instead:

const value = "20"
var thrower = () => { throw Error("bad things"); }
const x: string | never = "10" === value ? thrower() : "hello";

If this is truly what you intend to do, the following approach would be more readable:

//...

if(value !== "10")
    throw Error("bad things");

const x: string = "hello";

//...

Answer 6

When it comes to constructing languages, there is a distinction between statements and expressions. For example, assigning a value to x is a statement or operation rather than a value or expression.

Attempting something like the following won't work for the same reason:

const x : string | never = "10" === value ? for(var i in myArray) { /* do stuff */ } : "hello".

This goes against the rules of the language, although you may find ways to work around it using self-evaluation functions that theoretically evaluate as an expression.

To understand the difference between statements and expressions better, refer to this question.

In TypeScript, the never keyword is a peculiar type associated with control flow analysis. It prevents treating statements as expressions. If you prefer not to use immediately invoked function expressions, consider using a regular function instead:

const value = "20"
var thrower = () => { throw Error("bad things"); }
const x: string | never = "10" === value ? thrower() : "hello";

If this is truly what you intend to do, the following approach would be more readable:

//...

if(value !== "10")
    throw Error("bad things");

const x: string = "hello";

//...

Throwing in a ternary/conditional operator expression in Typescript 2

Answer №1

Answer №2

Answer №3

Similar questions

I keep encountering the issue where nothing seems to be accessible

The ts-loader seems to be malfunctioning (It appears that a suitable loader is required to handle this file type, as no loaders are currently set up to process it)

Experiencing an issue with type error when transitioning syntax from using require to import

Using Ng If with a boolean value to dynamically update the title of a webpage

Unable to create property within array in model

Upon executing the `npm start` command, the application experiences a crash

Tips for Decreasing Query Time with MatTable and MatTableDataSource

TypeScript: Error - .map() is an Invalid Function

Cannot compile Angular 4 Material table: Encountering unexpected closing tag

What is the process for initiating a Fargate task once a database instance has been successfully provisioned using AWS CDK

Avoiding the pitfalls of hierarchical dependency injection in Angular 6

Using Angular with Google Maps: Learn how to retrieve a list of markers from a map and implement onClick events for each one

The specified instant cannot be located in 'moment' while attempting to import {Moment} from 'moment' module

Utilizing a tuple for indexing in Typescript

What is the best approach to dealing with a non-TypeScript project that is requesting the installation of @types for

Relying on ModalController within an Angular/Ionic component leads to the error "Unable to resolve all parameters" for the service

Encountering 404 errors when reloading routes on an Angular Azure static web app

Potential null object in React/TypeScript

There was an error during compilation: Module not detected - Unable to locate './xxxx'

Opt for ion-select with a range of i to j options