Leveraging default values in generic implementations

Question

Leveraging default values in generic implementations

Imagine a scenario where the following code is present:

type QueryResult<ResultType = string, ErrorType = string> = {
  result: ResultType,
} | {
  errors: ErrorType,
}

So, if I want to initialize my result, I can proceed like this:

const myResult: QueryResult = {
  result: "My result!",
};

In addition, when I need to modify the ResultType, it can be included in the generic type:

const myResult: QueryResult<number> = {
  result: 10,
  errors: null
};

However, what about changing the type value for errors? One way of achieving this is by doing the following:

// Although functional, specifying the default value is not ideal
const myErrorResult: QueryResult<string, MyErrorType> = {
  errors: {
    location: [1, 2],
    message: "Invalid argument!",
  }
};

Is there a way to skip specifying the ResultType? Is this even feasible? The main motive behind this query is to avoid providing default values for each generic type, especially when dealing with numerous generics. Attempts such as QueryResult<, string> and

QueryResult<ErrorType = MyErrorType>

have resulted in errors.

You can access the playground link here.

Thanks for your assistance!

NOTE: This example serves solely for illustrative purposes, acknowledging that it may not be an optimal representation method for errors/results.

typescript

Answer 1

Answer №1

Unfortunately, TypeScript does not natively support skipping over generic type parameters. Ongoing feature requests can be found at microsoft/TypeScript#10571 and microsoft/TypeScript#26242, although the specifics of how skipping should operate are still unclear. As a workaround, you can create a "marker" or "sigil" type, such as Default, to signal fallback behavior.

To implement this workaround, define a marker type Default with a private property:

declare class Default { private prop: string }

The Fallback<T, D> type will return T unless it's Default, in which case it falls back to D:

type Fallback<T, D> = T extends Default ? D : T;

Rename the original QueryResult as _QueryResult and introduce QueryResult using the fallback logic:

type _QueryResult<R, E> = { result: R } | { errors: E };

type QueryResult<R = Default, E = Default> =
  [Fallback<R, string>, Fallback<E, string>] extends [infer R, infer E] ?
  _QueryResult<R, E> : never;

You can now use QueryResult with fallbacks for generic types as needed:

const myResult: QueryResult = { result: "My result!" };

const myGenericResult: QueryResult<number> = { result: 10 }

const myErrorResult: QueryResult<Default, MyErrorType> = {
  errors: {
    location: [1, 2],
    message: "Invalid argument!",
  }
};

This workaround provides a solution, but may not align with expectations around type inference for some use cases. Explore alternatives that better suit your needs, and consider supporting existing feature requests on GitHub if none of the workarounds suffice.

Playground link to code

Answer 2

Unfortunately, TypeScript does not natively support skipping over generic type parameters. Ongoing feature requests can be found at microsoft/TypeScript#10571 and microsoft/TypeScript#26242, although the specifics of how skipping should operate are still unclear. As a workaround, you can create a "marker" or "sigil" type, such as Default, to signal fallback behavior.

To implement this workaround, define a marker type Default with a private property:

declare class Default { private prop: string }

The Fallback<T, D> type will return T unless it's Default, in which case it falls back to D:

type Fallback<T, D> = T extends Default ? D : T;

Rename the original QueryResult as _QueryResult and introduce QueryResult using the fallback logic:

type _QueryResult<R, E> = { result: R } | { errors: E };

type QueryResult<R = Default, E = Default> =
  [Fallback<R, string>, Fallback<E, string>] extends [infer R, infer E] ?
  _QueryResult<R, E> : never;

You can now use QueryResult with fallbacks for generic types as needed:

const myResult: QueryResult = { result: "My result!" };

const myGenericResult: QueryResult<number> = { result: 10 }

const myErrorResult: QueryResult<Default, MyErrorType> = {
  errors: {
    location: [1, 2],
    message: "Invalid argument!",
  }
};

This workaround provides a solution, but may not align with expectations around type inference for some use cases. Explore alternatives that better suit your needs, and consider supporting existing feature requests on GitHub if none of the workarounds suffice.

Playground link to code

Answer 3

Answer №2

jcalz's response is excellent, however I have an alternative suggestion to consider.

One simple solution could be to establish a distinct type specifically for this scenario:

type AlternateErrorQueryType<OtherErrorType = string> = QueryType<string, OtherErrorType>;;

Answer 4

jcalz's response is excellent, however I have an alternative suggestion to consider.

One simple solution could be to establish a distinct type specifically for this scenario:

type AlternateErrorQueryType<OtherErrorType = string> = QueryType<string, OtherErrorType>;;

Leveraging default values in generic implementations

Answer №1

Answer №2

Similar questions

What is the best approach for managing optional object input parameters while also verifying the presence and accuracy of that specific property?

Having trouble getting tsserver-plugins to function properly in either Atom or VSC

How to retrieve a Typescript variable within an ngIf conditional statement in Angular

How can I access a TypeScript variable from a global var set in a .cshtml file?

Is there a workaround for utilizing reducer dispatch outside of a React component without relying on the store?

The Angular-Chart.js chart fails to display when data is automatically inserted

The type 'number' cannot be assigned to the type 'Element'

What is the best way to specify a function type that takes an argument of type T and returns void?

How to Position Logo in the Center of MUI AppBar in React

Use Angular's super.ngOnDestroy method for handling cleanup/unsubscribing

Can a TypeScript generic version of the Y-combinator be successfully executed?

The art of crafting informative error log messages in Protractor using TypeScript

Choose an option from a selection and showcase it

The ngFor directive in Angular should be used with the Filter pipe to ensure that

Tips for utilizing RouterLink within an HTML template

What is the process for generating an object type that encompasses all the keys from an array type?

The process of incorporating types into Node.js and TypeScript for handling req and res objects

Tips for importing a .geojson document in TypeScript using webpack?

Utilizing Office.js: Incorporating Angular CLI to Call a Function in a Generated Function-File

Inactive function