What method can be used to determine a number that is nonzero?

Question

What method can be used to determine a number that is nonzero?

Defining the type of Result has presented some challenges for me. It should adhere to one of the following patterns:

type Result<Some> = { code: 0; some_result: ...}
// or
type Result = { code: NonZero; message: string}

How can I properly type this?

Perhaps, this question can be broken down into two parts:

Developing NonZero (note that Exclude<number, 0> doesn't seem to work)
Providing typings for the generic Result

Updates

I have crafted a functional snippet as shown below:

type Result<TCode extends number, T extends {} = {}> = TCode extends 0
  ? { code: 0; } & T
  : { code: TCode; reason: string };

type SomeResult = {some_result: string}

function getSomeResult(): Result<0 | -1 | 6007 | 114514, SomeResult> {
  return {
    code: 0,
    some_result: ''
  }
}

const result = getSomeResult()

switch (result.code) {
  case 0:
    // this is wrong: reason should be void
    result.reason
    // this is ok:
    result.some_result
    break
  default:
    // this is ok: there's always a reason when code is non-zero
    result.reason
}

Currently, the TS compiler is able to deduce that the other property defaults to void. Nonetheless, I am required to specify all potential non-zero values for code as a type parameter.

What's the best way to type NonZero?

typescript typescript-generics

Answer 1

Answer №1

It's impossible to input the keyword number without including zero, but this code snippet tries to closely mimic your syntax by introducing a cast to clarify the union type in the switch statement.

type Result<TCode extends number, T extends {} = {}> = TCode extends 0
  ? { code: 0; } & T
  : { code: TCode; reason: string };

type SomeResult = {some_result: string}

function getSomeResult(): Result<0, SomeResult> | Result<number> {
  if (Math.random()<0.5){
    return {
      code: 0,
      some_result: ''
    };
  }
  else {
    return {
      code: Math.floor(Math.random()+1),
      reason:""
    };
  }
}
function cast<T>(x:any): asserts x is T {}
const result = getSomeResult()
switch (result.code) {
  case 0:
    cast<Result<0,SomeResult>>(result);
    // this is incorrect: reason should be void
    result.reason
    // this is correct:
    result.some_result
    break
  default:
    cast<Result<number>>(result);
    // this is correct: there's always a reason when code is non-zero
    result.reason
}

typescript playground

A more conventional approach in TypeScript would involve adding a 'kind' field for clarification, thus eliminating the need for a cast.

type ResultNormal<T> = {
   kind: "normal";
} & T;
type ResultAbnormal = { 
   kind: "abnormal";
   code: TCode; reason: string 
};
function getSomeResult(): 
  ResultNormal<{some_result: string}> | ResultAbnormal {
  ...
}

This way, you can simply switch based on the 'kind' property.

Answer 2

It's impossible to input the keyword number without including zero, but this code snippet tries to closely mimic your syntax by introducing a cast to clarify the union type in the switch statement.

type Result<TCode extends number, T extends {} = {}> = TCode extends 0
  ? { code: 0; } & T
  : { code: TCode; reason: string };

type SomeResult = {some_result: string}

function getSomeResult(): Result<0, SomeResult> | Result<number> {
  if (Math.random()<0.5){
    return {
      code: 0,
      some_result: ''
    };
  }
  else {
    return {
      code: Math.floor(Math.random()+1),
      reason:""
    };
  }
}
function cast<T>(x:any): asserts x is T {}
const result = getSomeResult()
switch (result.code) {
  case 0:
    cast<Result<0,SomeResult>>(result);
    // this is incorrect: reason should be void
    result.reason
    // this is correct:
    result.some_result
    break
  default:
    cast<Result<number>>(result);
    // this is correct: there's always a reason when code is non-zero
    result.reason
}

typescript playground

A more conventional approach in TypeScript would involve adding a 'kind' field for clarification, thus eliminating the need for a cast.

type ResultNormal<T> = {
   kind: "normal";
} & T;
type ResultAbnormal = { 
   kind: "abnormal";
   code: TCode; reason: string 
};
function getSomeResult(): 
  ResultNormal<{some_result: string}> | ResultAbnormal {
  ...
}

This way, you can simply switch based on the 'kind' property.

What method can be used to determine a number that is nonzero?

Updates

Answer №1

Similar questions

Struggling to transfer RDS database instance metrics to a different stack

The correct way to incorporate a global property into a component template (using Vue 3, Vite, TypeScript, and the Composition API)

React-pdf has encountered a situation where more hooks were rendered compared to the last render cycle

How can CSS variables be applied to a hover property within an Angular directive?

Preparing a component for evaluation

Guide on setting up @types from an NPM module containing the "@" symbol in its title

`Creating a union of prop types in TypeScript and React`

Utilizing proxies and leveraging the power of the Map collection in tandem

Having trouble locating the module for my custom TypeScript module

Module augmentations do not allow for exports or export assignments

What is the process for configuring the Authorization Header in ng2-signalr?

Next and previous buttons on Bootstrap carousel are not functioning properly with certain pop-up modals in a React application

The search is fruitless for a distinguishable entity '[object Object]' falling under the category of 'object'. In Angular 8, NgFor exclusively allows binding to Iterables like Arrays

I'm unsure how to utilize the generic type in this particular scenario. It's a bit confusing to me

Encountering a TypeError while utilizing a custom hook for an Apollo mutation operation

How can I prevent scrolling in Angular's cdk-virtual-scroll feature?

What could be the reason behind the absence of this.props.onLayout in my React Native component?

Unable to view loggly-winston debug logs on the user interface

Error: Unable to locate namespace 'google' in TypeScript

Utilizing a loaded variable containing data from an external API request within the useEffect() hook of a React component