Is there a way to prompt the compiler to generate an error when a type cannot be set to `undefined`

Question

Is there a way to prompt the compiler to generate an error when a type cannot be set to `undefined`

I'm working with a type called ILoadedValue<TValue>, which acts as a wrapper for types that can potentially be undefined. However, I want to prevent situations where TValue cannot be undefined, as it's more efficient to use the actual value of undefined to signify that the type is still loading.

Currently, my implementation involves using TValue extends undefined.

/**
 * {@link ILoadedValue} is necessary to provide atomic information
 * about value and its loaded status for values that may be `undefined`,
 * it should be used like `ILoadedValue<TValue> | undefined`
 *
 * Please note that we should steer clear of scenarios where `TValue` cannot be `undefined`
 * (as in such cases, it's more efficient not to wrap the type,
 * but rather to directly use `undefined` to indicate that the type is still being loaded)
 */
export interface ILoadedValue<TValue extends undefined> {
  value: TValue;
}

However, when this type is utilized within another type, such as:

export class SomeClass<TValue> {
  loadedValue: ILoadedValue<TValue | undefined> | undefined;
}

We encounter an error:

TS2344: Type TValue | undefined does not satisfy the constraint undefined Type TValue is not assignable to type undefined SomeClass.ts(40, 3): This type parameter might need an extends undefined constraint.

Do you have any suggestions for an improved approach to address these conflicts?

export class SomeClass<TValue> {
  // This should work
  loadedValue: ILoadedValue<TValue | undefined> | undefined;
}

export class SomeClass2<TValue> {
  // The compiler should raise an error here, as `TValue` is not guaranteed to include `undefined`
  loadedValue: ILoadedValue<TValue> | undefined;
}

typescript

Answer 1

Answer №1

Avoid restricting TValue to undefined as it limits TValue to only being a subtype of undefined, which usually translates to just undefined or the type never. Instead, aim for the opposite scenario where TValue is a supertype of undefined. Rather than using TValue extends undefined, opt for undefined extends TValue, or even TValue super undefined. Essentially, enforce that undefined acts as a lower bound rather than an upper limit.

TypeScript does not natively support lower bound constraints at present. Although there exists a feature request for this functionality on GitHub at microsoft/TypeScript#14520, it has yet to be incorporated into the language. Consider showing your support for this proposal by giving it a like 👍, but in the meantime, you'll need a workaround.

To address this issue, you can simulate a lower bound constraint by employing a conditional type like this:

interface ILoadedValue<TValue extends (undefined extends TValue ? unknown : never)> {
  value: TValue;
}

class SomeClass<TValue> {
  loadedValue: ILoadedValue<TValue | undefined> | undefined; // works
}

class SomeClass2<TValue> {
  loadedValue: ILoadedValue<TValue> | undefined; // throws error
}

This method functions because when undefined extends TValue evaluates to true, the constraint becomes TValue extends unknown, which always succeeds. However, when undefined extends TValue is false, the constraint changes to TValue extends never, which rarely satisfies the condition.

While effective, this approach may seem cumbersome.

Depending on your specific requirements, you might opt to forego lower bound constraints and utilize a union to include undefined across all instances utilizing TValue. Instead of defining interface F<T super X> {⋯T⋯}, consider utilizing interface F {⋯(U | X)⋯}whereTis synonymous withT | X`. These approaches are essentially equivalent, simply articulating the concept using different type variables.

In your specific context, the solution would resemble the following:

interface ILoadedValue<UValue> {
  value: UValue | undefined;
}

class SomeClass<TValue> {
  loadedValue: ILoadedValue<TValue | undefined> | undefined; // works
}

class SomeClass2<TValue> {
  loadedValue: ILoadedValue<TValue> | undefined; // works 
  // since it mirrors SomeClass<TValue>
}

Now, including ILoadedValue<TValue> will consistently incorporate undefined. While this might not suit every use case, it offers a more straightforward alternative.

Playground link for reference

Answer 2

Avoid restricting TValue to undefined as it limits TValue to only being a subtype of undefined, which usually translates to just undefined or the type never. Instead, aim for the opposite scenario where TValue is a supertype of undefined. Rather than using TValue extends undefined, opt for undefined extends TValue, or even TValue super undefined. Essentially, enforce that undefined acts as a lower bound rather than an upper limit.

TypeScript does not natively support lower bound constraints at present. Although there exists a feature request for this functionality on GitHub at microsoft/TypeScript#14520, it has yet to be incorporated into the language. Consider showing your support for this proposal by giving it a like 👍, but in the meantime, you'll need a workaround.

To address this issue, you can simulate a lower bound constraint by employing a conditional type like this:

interface ILoadedValue<TValue extends (undefined extends TValue ? unknown : never)> {
  value: TValue;
}

class SomeClass<TValue> {
  loadedValue: ILoadedValue<TValue | undefined> | undefined; // works
}

class SomeClass2<TValue> {
  loadedValue: ILoadedValue<TValue> | undefined; // throws error
}

This method functions because when undefined extends TValue evaluates to true, the constraint becomes TValue extends unknown, which always succeeds. However, when undefined extends TValue is false, the constraint changes to TValue extends never, which rarely satisfies the condition.

While effective, this approach may seem cumbersome.

Depending on your specific requirements, you might opt to forego lower bound constraints and utilize a union to include undefined across all instances utilizing TValue. Instead of defining interface F<T super X> {⋯T⋯}, consider utilizing interface F {⋯(U | X)⋯}whereTis synonymous withT | X`. These approaches are essentially equivalent, simply articulating the concept using different type variables.

In your specific context, the solution would resemble the following:

interface ILoadedValue<UValue> {
  value: UValue | undefined;
}

class SomeClass<TValue> {
  loadedValue: ILoadedValue<TValue | undefined> | undefined; // works
}

class SomeClass2<TValue> {
  loadedValue: ILoadedValue<TValue> | undefined; // works 
  // since it mirrors SomeClass<TValue>
}

Now, including ILoadedValue<TValue> will consistently incorporate undefined. While this might not suit every use case, it offers a more straightforward alternative.

Playground link for reference

Is there a way to prompt the compiler to generate an error when a type cannot be set to `undefined`

Answer №1

Similar questions

No updates found (Angular)

Designing personalized plugins with Typescript in Nuxt

A guide on launching a Vite React application from a subdirectory

Depend on a mapping function to assign a value to every option within a discriminated union

Merging two arrays concurrently in Angular 7

Interfaces in Typescript

Tips for inserting a string into an array nested within an object stored in a state array

The useState variable remains unchanged even after being updated in useEffect due to the event

Arranging Objects by Alphabetical Order in Typescript

Leveraging ES6 Symbols in Typescript applications

Using TypeScript to Import Modules without Default Exports (CommonJS)

Code error TS2345 occurs when assigning the argument of type '{ headers: HttpHeaders; }' to a parameter of type 'RequestOptionsArgs'. This indicates a mismatch in the type of data being passed, causing an

Utilizing TypeScript for dynamic invocation of chalk

What exactly does RouteComponentProps entail?

Creating a custom React hook in TypeScript to handle mouse events

Type inference in TypeScript with transitivity

Validate the button's status in Ionic

Is it possible to combine TypeScript modules into a single JavaScript file?

Tips for updating the value.replace function for the "oninput" attribute within Angular 7

Creating encoded objects for a content-type of `application/x-www-form-urlencoded`