How can we limit the generic type T in TypeScript to ensure it is not undefined?

Question

How can we limit the generic type T in TypeScript to ensure it is not undefined?

I have created a function called get(o, key), which is designed to work with any Object that meets the criteria of the { get: (key: K) => R } interface.

Furthermore, I am interested in restricting the result variable R to not allow it to be undefined. How can this restriction be implemented?

Is there a way to modify the example provided below so that it does not compile due to the fact that the method

Params::get(key: string): number | undefined

may potentially return undefined?

function get<K, R>(o: { get: (key: K) => R }, key: K): R {
  return o.get(key);
}

class Params {
  constructor(public values: { [key: string]: number }) { }

  get(key: string): number | undefined {
    return this.values[key]
  }
}
const params = new Params({ a: 10 });

console.log(get(params, "a"))

typescript

Answer 1

Answer №1

To achieve this, you can utilize NonNullable<T> as an interface-type on the get's R, rather than using it as a constraint on the type-parameters. Here is how you can implement it:

function get<K, R>( o: { get: (key: K) => NonNullable<R> }, key: K ): NonNullable<R> {
  return o.get(key);
}

When trying to use the code snippet provided, you may encounter an error like:

const params = new Params({ a: 10 });

console.log(get(params, "a"))

An issue arises where the argument of type 'Params' cannot be assigned to the parameter of type '
{ get: (key: "a") => number; }
'.
The types returned by 'get(...)' are incompatible.
Type 'number | undefined' is not the same as 'number'.
Type 'undefined' cannot be assigned to type 'number'.(2345)

It's important to note that NonNullable<T> restricts both null and undefined, which may or may not align with your application requirements.

Update

The definition of NonNullable<T> in lib.es6.d.ts is as follows:

/**
 * Exclude null and undefined from T
 */
type NonNullable<T> = T extends null | undefined ? never : T;

A modification can be made to only exclude undefined:

type NonUndefined<T> = T extends undefined ? never : T;

If we update the get function accordingly:

type NonUndefined<T> = T extends undefined ? never : T;

function get<K, R>(o: { get: (key: K) => NonUndefined<R> }, key: K): NonUndefined<R> {
  return o.get(key);
}

This modification ensures that class Params's get method can return number | null but not number | undefined.

Answer 2

To achieve this, you can utilize NonNullable<T> as an interface-type on the get's R, rather than using it as a constraint on the type-parameters. Here is how you can implement it:

function get<K, R>( o: { get: (key: K) => NonNullable<R> }, key: K ): NonNullable<R> {
  return o.get(key);
}

When trying to use the code snippet provided, you may encounter an error like:

const params = new Params({ a: 10 });

console.log(get(params, "a"))

An issue arises where the argument of type 'Params' cannot be assigned to the parameter of type '
{ get: (key: "a") => number; }
'.
The types returned by 'get(...)' are incompatible.
Type 'number | undefined' is not the same as 'number'.
Type 'undefined' cannot be assigned to type 'number'.(2345)

It's important to note that NonNullable<T> restricts both null and undefined, which may or may not align with your application requirements.

Update

The definition of NonNullable<T> in lib.es6.d.ts is as follows:

/**
 * Exclude null and undefined from T
 */
type NonNullable<T> = T extends null | undefined ? never : T;

A modification can be made to only exclude undefined:

type NonUndefined<T> = T extends undefined ? never : T;

If we update the get function accordingly:

type NonUndefined<T> = T extends undefined ? never : T;

function get<K, R>(o: { get: (key: K) => NonUndefined<R> }, key: K): NonUndefined<R> {
  return o.get(key);
}

This modification ensures that class Params's get method can return number | null but not number | undefined.

Answer 3

Answer №2

In TypeScript, there are no explicit subtraction or negated types available. However, you can represent a type that is "not undefined" as "{} | null". Any value that is not null or undefined can be assigned to the empty type {}. If you specifically want to allow null but not undefined, you can use the type {} | null:

function fetch<K, R extends {} | null>(data: { get: (key: K) => R }, key: K): R {
    return data.get(key);
}

This function behaves as expected:

console.log(fetch(data, "a")); // error!
// -----------> ~~~~~~
// Type 'string | undefined' is not assignable to type '{} | null'

On the other hand, if the type only returns string instead of string | undefined, it will not result in an error:

const stringFetcher = { get(key: string) { return "Hello" } };
console.log(fetch(stringFetcher, "b")); // okay

I hope this explanation clarifies things for you. Good luck with your TypeScript coding!

Link to Playground for testing code

Answer 4

In TypeScript, there are no explicit subtraction or negated types available. However, you can represent a type that is "not undefined" as "{} | null". Any value that is not null or undefined can be assigned to the empty type {}. If you specifically want to allow null but not undefined, you can use the type {} | null:

function fetch<K, R extends {} | null>(data: { get: (key: K) => R }, key: K): R {
    return data.get(key);
}

This function behaves as expected:

console.log(fetch(data, "a")); // error!
// -----------> ~~~~~~
// Type 'string | undefined' is not assignable to type '{} | null'

On the other hand, if the type only returns string instead of string | undefined, it will not result in an error:

const stringFetcher = { get(key: string) { return "Hello" } };
console.log(fetch(stringFetcher, "b")); // okay

I hope this explanation clarifies things for you. Good luck with your TypeScript coding!

Link to Playground for testing code

Answer 5

Answer №3

NonNullable eliminates both null and undefined.

In contrast, this excludes only undefined.

type NonUndefined<T> = NonNullable<T> | null;

Conversely, this excludes only null.

type NonNull<T> = NonNullable<T> | undefined;

Answer 6

NonNullable eliminates both null and undefined.

In contrast, this excludes only undefined.

type NonUndefined<T> = NonNullable<T> | null;

Conversely, this excludes only null.

type NonNull<T> = NonNullable<T> | undefined;

How can we limit the generic type T in TypeScript to ensure it is not undefined?

Answer №1

Update

Answer №2

Answer №3

Similar questions

I continue to encounter the same error while attempting to deliver data to this form

Is it possible to effortlessly associate a personalized string with an identifier within an HTML element utilizing Angular2?

In the context of React Typescript, the term 'Component' is being mistakenly used as a type when it actually refers to a value. Perhaps you intended to use 'typeof Component' instead?

How can we combine two phone calls and display the outcomes using typeahead ngx-bootstrap?

Issue with Socket.io: Data not received by the last user who connected

Is it possible for Typescript interface A to extend B while lacking certain properties from B?

Leveraging Expose in combination with class-transformer

Leveraging React and TypeScript's capabilities to pass around arguments efficiently

Integrate Angular 2 into the current layout of Express framework

The functionality of translations within a TypeScript object is currently malfunctioning

If a generic string argument is not specified as a string literal, it will not be narrowed unless it is the first argument

How can I remove specific items from a PrimeNG PickList?

Tips for converting string values from an Observable to numbers using the parseFloat() method

Utilizing ngx-logger Dependency in Angular 6 for Efficient Unit Testing

What is the safest method to convert a nested data structure into an immutable one while ensuring type safety when utilizing Immutable library?

Is it possible for transclusion to display content from external sources using *ngIf and <ng-content>?

Tips for preventing duplicate entries in an AG Grid component within an Angular application

What are the downsides of utilizing a global function over a private static method in Typescript?

When comparing TypeScript class functions with regular functions and variables, which one yields better performance?

Using Typescript: Utilizing generic types within the parent class