Creating a function that leverages both generic types and variadic arguments for enhanced functionality

Question

Creating a function that leverages both generic types and variadic arguments for enhanced functionality

Imagine a more streamlined design:

type BaseResponse<T> = {
  success: boolean;
  data?: T;
}

Consider the following function, which merges multiple BaseResponse objects into one:

zip<T1, T2>(response1: BaseResponse<T1>, response2: BaseResponse<T2>): BaseResponse<T1 & T2> {
    let success = true;
    let data: Partial<T1 & T2> = {};

    if (!response1.success) success = false;
    else data = {...data, ...response1.data};

    if (!response2.success) success = false;
    else data = {...data, ...response2.data};

    return {
        success,
        data: success ? data as any : undefined,
    };
}

This approach is effective for handling two arguments. Is there a way to generalize it for an arbitrary number of arguments T1, T2, ..., TN?

In terms of implementation, utilizing a for loop for iterating through arguments could simplify the process. However, I am interested in how the function signature would need to be adapted to accommodate this flexibility.

typescript

Answer 1

Answer №1

Your inquiry seems to revolve around the call signature, assuming you have the capability to manage the implementation on your own.

It's worth noting that the UnionToIntersection<T> type discussed in Transform union type to intersection type may not be the best solution for your scenario. If any of the inputs for your BaseResponse<T> have a union type for T, using UnionToIntersection could lead to erroneous intersections. Therefore, calling zip() on a BaseResponse<X | Y> should yield a BaseResponse<X | Y>, not BaseResponse<X & Y>.

For instance, here is the expected behavior:

declare const r0: BaseResponse<{ a: string }>;
declare const r1: BaseResponse<{ b: number }>;
declare const r2: BaseResponse<{ c: boolean }>;
declare const r3: BaseResponse<{ d: Date } | { e: HTMLElement }>;
const zipped = zip(r0, r1, r2, r3);
/* const zipped: BaseResponse<
   {a: string} & {b: number} & {c: boolean} & ({d: Date} | {e: HTMLElement})
                     still a union ----------> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>*/

To achieve this, manipulating the tuple of inputs directly and creating a TupleToIntersection<T> utility type might be necessary. Here is a possible implementation:

type TupleToIntersection<T extends any[]> =
    { [I in keyof T]: (x: T[I]) => void } extends 
    Record<number, (x: infer I) => void> ? I : never;

This works similarly to UnionToIntersection, positioning each tuple element contravariantly and then inferring a single type from that position to obtain the intersection.

The call signature of zip() would then look like this:

declare function zip<T extends any[]>(
    ...response: { [I in keyof T]: BaseResponse<T[I]> }
): BaseResponse<TupleToIntersection<T>>;

You can verify its functionality by testing as described above.

Access the Playground link to view the code

Answer 2

Your inquiry seems to revolve around the call signature, assuming you have the capability to manage the implementation on your own.

It's worth noting that the UnionToIntersection<T> type discussed in Transform union type to intersection type may not be the best solution for your scenario. If any of the inputs for your BaseResponse<T> have a union type for T, using UnionToIntersection could lead to erroneous intersections. Therefore, calling zip() on a BaseResponse<X | Y> should yield a BaseResponse<X | Y>, not BaseResponse<X & Y>.

For instance, here is the expected behavior:

declare const r0: BaseResponse<{ a: string }>;
declare const r1: BaseResponse<{ b: number }>;
declare const r2: BaseResponse<{ c: boolean }>;
declare const r3: BaseResponse<{ d: Date } | { e: HTMLElement }>;
const zipped = zip(r0, r1, r2, r3);
/* const zipped: BaseResponse<
   {a: string} & {b: number} & {c: boolean} & ({d: Date} | {e: HTMLElement})
                     still a union ----------> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>*/

To achieve this, manipulating the tuple of inputs directly and creating a TupleToIntersection<T> utility type might be necessary. Here is a possible implementation:

type TupleToIntersection<T extends any[]> =
    { [I in keyof T]: (x: T[I]) => void } extends 
    Record<number, (x: infer I) => void> ? I : never;

This works similarly to UnionToIntersection, positioning each tuple element contravariantly and then inferring a single type from that position to obtain the intersection.

The call signature of zip() would then look like this:

declare function zip<T extends any[]>(
    ...response: { [I in keyof T]: BaseResponse<T[I]> }
): BaseResponse<TupleToIntersection<T>>;

You can verify its functionality by testing as described above.

Access the Playground link to view the code

Answer 3

Answer №2

There may be a more efficient approach to solving this without relying on the UnionToIntersection type. However, the following code should suffice:

I came across the UnionToIntersection type from this source: link

type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
  x: infer I
) => void
  ? I
  : never;

function zipSpread<T extends BaseResponse<any>[]>(
  ...responses: T
): BaseResponse<UnionToIntersection<T[number]['data']>> {
  // your implementation logic here.
}

Answer 4

There may be a more efficient approach to solving this without relying on the UnionToIntersection type. However, the following code should suffice:

I came across the UnionToIntersection type from this source: link

type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
  x: infer I
) => void
  ? I
  : never;

function zipSpread<T extends BaseResponse<any>[]>(
  ...responses: T
): BaseResponse<UnionToIntersection<T[number]['data']>> {
  // your implementation logic here.
}

Answer 5

Answer №3

If you want to use the UnionToIntersection utility, make sure to also incorporate the {success: false} scenario:

Check it out here!

type BaseResponse<T> = {
  success: boolean;
  data?: T;
}

type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends ((arg: infer I) => void) ? I : never
type Simplify<T> = {[K in keyof T]: T[K] extends Function ? T[K] extends (...args: infer B) => infer A ? (...args: B) => Simplify<A> : never : Simplify<T[K]>} extends infer A ? A : never;

function zip<T extends object, R extends BaseResponse<T>, const A extends R[]>(...responses: A): Simplify<UnionToIntersection<A[number]>> {

    const success = responses.every(response => response.success);

    if(!success) return {success} as any;

    const data = {};

    for(const response of responses){
        Object.assign(data, response);
    }

    return {
        success,
        data,
    } as any;
}

declare const r1: BaseResponse<Readonly<{test: 'test'}>>;
declare const r2: BaseResponse<Readonly<{test2: 2}>>;

const d = zip({success: true, data:{test: 'test'}}, {success: true, data:{test1: 1}});
/*
const d: {
    readonly success: true;
    readonly data: {
        readonly test: "test";
        readonly test1: 1;
    };
}
*/
const d2 = zip(r1, r2);
/*
const d2: {
    success: boolean;
    data?: {
        readonly test: "test";
        readonly test2: 2;
    } | undefined;
}
*/

Answer 6

If you want to use the UnionToIntersection utility, make sure to also incorporate the {success: false} scenario:

Check it out here!

type BaseResponse<T> = {
  success: boolean;
  data?: T;
}

type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends ((arg: infer I) => void) ? I : never
type Simplify<T> = {[K in keyof T]: T[K] extends Function ? T[K] extends (...args: infer B) => infer A ? (...args: B) => Simplify<A> : never : Simplify<T[K]>} extends infer A ? A : never;

function zip<T extends object, R extends BaseResponse<T>, const A extends R[]>(...responses: A): Simplify<UnionToIntersection<A[number]>> {

    const success = responses.every(response => response.success);

    if(!success) return {success} as any;

    const data = {};

    for(const response of responses){
        Object.assign(data, response);
    }

    return {
        success,
        data,
    } as any;
}

declare const r1: BaseResponse<Readonly<{test: 'test'}>>;
declare const r2: BaseResponse<Readonly<{test2: 2}>>;

const d = zip({success: true, data:{test: 'test'}}, {success: true, data:{test1: 1}});
/*
const d: {
    readonly success: true;
    readonly data: {
        readonly test: "test";
        readonly test1: 1;
    };
}
*/
const d2 = zip(r1, r2);
/*
const d2: {
    success: boolean;
    data?: {
        readonly test: "test";
        readonly test2: 2;
    } | undefined;
}
*/

Answer 7

Answer №4

To solve the issue at hand, one could consider utilizing a union approach such as

type MergeTypes<U> = 
  (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

type BaseResponse<T> = {
  success: boolean;
  data?: T;
};

function combineResponses<T extends any[]>(
  ...responses: { [K in keyof T]: BaseResponse<T[K]> }
): BaseResponse<MergeTypes<T[number]>> {
  let success = true;
  let data: Partial<MergeTypes<T[number]>> = {};

  for (const response of responses) {
    if (!response.success) {
      success = false;
    } 
    if (response.data) {
      data = { ...data, ...response.data };
    }
  }

  return {
    success,
    data: success ? (data as MergeTypes<T[number]>) : (data ? data as MergeTypes<T[number]> : undefined),
  };
}

This method allows for the combination of different types and their subsequent inclusion in the base response.

For an illustration of its usage, refer to this link.

Answer 8

To solve the issue at hand, one could consider utilizing a union approach such as

type MergeTypes<U> = 
  (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

type BaseResponse<T> = {
  success: boolean;
  data?: T;
};

function combineResponses<T extends any[]>(
  ...responses: { [K in keyof T]: BaseResponse<T[K]> }
): BaseResponse<MergeTypes<T[number]>> {
  let success = true;
  let data: Partial<MergeTypes<T[number]>> = {};

  for (const response of responses) {
    if (!response.success) {
      success = false;
    } 
    if (response.data) {
      data = { ...data, ...response.data };
    }
  }

  return {
    success,
    data: success ? (data as MergeTypes<T[number]>) : (data ? data as MergeTypes<T[number]> : undefined),
  };
}

This method allows for the combination of different types and their subsequent inclusion in the base response.

For an illustration of its usage, refer to this link.

Creating a function that leverages both generic types and variadic arguments for enhanced functionality

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Jasmine : Techniques for monitoring a method callback using method.then()

How to reference an object from an external file in TypeScript using Ionic 2 and Angular 2

Transform the look of the GroupLabels in MUI Autocomplete components within a React environment

Cease the execution of the express function once a response has been sent

Creating a custom type declaration for .lottie files in Next.js

Angular 4 is unable to attach to 'formGroup' as it is not recognized as a valid property of 'form'

Tips for managing the data type of a bound value through ngModel: preventing number distortion to string

I'm facing difficulty transferring information to another component

Retrieve the document id along with the corresponding data from a collection

Conceal a row in a table using knockout's style binding functionality

Default exports are not supported in TypeScript

What is the best way to include TypeScript definition files in version control?

Exploring Typescript within React: Creating a property on the current instance

I'm having some trouble grasping the concept of the useReducer hook

What is the method for generating a data type from an array of strings using TypeScript?

SystemJS is loading classes that are extending others

The default value is not appearing in the Select Box when using [(ngModel)] in Angular 2

Steps for positioning grid lines behind the flex container

Angular local storage override problem

Error alert: Ionic detected a SyntaxError due to a missing closing parenthesis on the emulator