Utilizing mapped conditional types in TypeScript for generic implementations

Question

Utilizing mapped conditional types in TypeScript for generic implementations

Can generics be leveraged with mapped types to map method types?

For instance, is it feasible to construct a mapped type that adds a first argument of type number to each method?

Here's an example in pseudo code (though it won't run):

interface Method<TS extends any[], R> { 
  (...args: TS): R;
}
interface NumberedMethod<TS extends any[], R> { 
  (n: number, ...args: TS): R;
}


type Numbered<T> = {
  // ERROR! Unable to use generics here??
  <TS extends any[], R>[K in keyof T]: T[K] extends NumberedMethod<TS, R>? T[K]: T[K] extends Method<TS, R>: NumberedMethod<TS, R>: never;
};

Is there a way to achieve this?

typescript

Answer 1

Answer №1

To extract the generic arguments TS and R from a method, you can utilize the infer keyword before a type name in a conditional type. This technique is explained in detail in this resource about Type Inference in Conditional Types. The following code snippet demonstrates how to achieve this:

interface Method<TS extends any[], R> { 
  (...args: TS): R;
}
interface NumberedMethod<TS extends any[], R> { 
  (n: number, ...args: TS): R;
}


type Numbered<T> = {
    [K in keyof T]: T[K] extends Method<infer TS, infer R>? NumberedMethod<TS, R>: T[K];
};

type WithNumber = Numbered<{
    foo : number,
    bar(a: string): void
}> 
// same as 
// type WithNumber = {
//   foo: never;
//   bar: NumberedMethod<[string], void>; // This gets expanded by code completion when accessing the method usually 
// }

Answer 2

To extract the generic arguments TS and R from a method, you can utilize the infer keyword before a type name in a conditional type. This technique is explained in detail in this resource about Type Inference in Conditional Types. The following code snippet demonstrates how to achieve this:

interface Method<TS extends any[], R> { 
  (...args: TS): R;
}
interface NumberedMethod<TS extends any[], R> { 
  (n: number, ...args: TS): R;
}


type Numbered<T> = {
    [K in keyof T]: T[K] extends Method<infer TS, infer R>? NumberedMethod<TS, R>: T[K];
};

type WithNumber = Numbered<{
    foo : number,
    bar(a: string): void
}> 
// same as 
// type WithNumber = {
//   foo: never;
//   bar: NumberedMethod<[string], void>; // This gets expanded by code completion when accessing the method usually 
// }

Utilizing mapped conditional types in TypeScript for generic implementations

Answer №1

Similar questions

Encountered an issue with Angular while trying to import scss variables: Module parse failed due to an unexpected token at

Execute a function that handles errors

Creating object properties dynamically based on specific conditions

Exploring NextJS with Typescript

Tips on passing an object as data through Angular router navigation:

Creating type definitions in TypeScript for an object received from an API with an unknown data type, and attempting to enforce specific types on it

Utilizing TypeScript Types for Supabase Integration

An interface with a specific purpose that inherits from another interface

Challenges arising from the usage of Vue component state in TypeScript

Issue regarding custom CSS implementation in Angular project

Unlocking the power of global JavaScript variables within an Angular 2 component

Exploring the implementation of custom global declaration in the latest version of NextJS, version

Is it possible to implement a different termination condition when using *ngFor in Angular 2?

How to efficiently filter an array containing nested objects using TypeScript

Getting Form Value in Component.ts with Angular 5

Tips for decoding the excel PRODUCT function

The specified argument '{ type: string; weight: number; }' cannot be assigned to the parameter of type 'never' in Angular

Tips for measuring the number of elements in a table using Angular

What is the process of invoking an external JavaScript function in Angular 5?

Discovering subtype relationships in JSON with TypeScript