限制两个泛型的组合

Question

Is there a way in TypeScript to express "You can pass in any two objects, as long as their combination satisfies type X"?

So, if I have the following function:

function myFunction(options: {x: number, y: string}){
}

And then, I have a function, that wants to call this function using an combination of two objects:

function callMyFunction<A,B>(a:A,b:B){
    myFunction({...a,...b})
} 

And then it would compile if I did one of the following:

callMyFunction({},{x:1,y:"hello"})
callMyFunction({x:1},{y:"hello"})
callMyFunction({x:1,y:"hello"},{})

But would not compile if I did for example:

callMyFunction({x:1},{}) //y missing
callMyFunction({},{y:"hello"}) //x missing
callMyFunction({},{}) //x and y missing

I know that it's possible to restrict a generic type using extends . But is there a way to restrict the combination of two generic types? I imagine something like this:

function callMyFunction<A,B, A&B extends {x:number,y:string}>(a:A,b:B){
    myFunction({...a,...b})
}

Answer 1

Is there a way in TypeScript to express "You can pass in any two objects, as long as their combination satisfies type X"?

This is a terrific question! And the answer is YES.

Here is an approach (with a playground link) . The approach uses a heady mix of TypeScript and JavaScript features. It uses generics, rest ... parameters, array destructuring, conditional types, the never type, and a tuple type. It also tells the compiler that "we know more than it does" by using the as unknown as Options technique.

type Options = { x: number; y: string };
function myFunction(options: Options) {}

function callMyFunction<A, B>(
  ...[a, b]: A & B extends Options ? [A, B] : never
) {
  const options = { ...a, ...b };
  myFunction((options as unknown) as Options);
}

In callMyFunction , if the intersection of types A and B satisfies the type Options , then the two ... rest parameters will be of type A and B . If the intersection does not satisfy the type Options , then the rest parameters are of type never , which in turn tells the type checker to complain.

The result is that these all pass type checking...

callMyFunction({}, { x: 1, y: "hello" });
callMyFunction({ x: 1 }, { y: "hello" });
callMyFunction({ x: 1, y: "hello" }, {});

...and that none of these pass type checking.

/**
 * Argument of type `'[{ x: number; }, {}]'` is not assignable
 * to parameter of type `'never'`.ts(2345)
 */
callMyFunction({ x: 1 }, {});

/**
 * Argument of type `'[{}, { y: string; }]'` is not assignable
 * to parameter of type `'never'`.ts(2345)
 */
callMyFunction({}, { y: "hello" });

/**
 * Argument of type `'[{}, {}]'` is not assignable
 * to parameter of type `'never'`.ts(2345)
 */
callMyFunction({}, {});

The resultant error messages could use improvement. As is, the error messages do not tell developers much about the required arguments. Someone with more TypeScript knowledge than I have can chime in about whether we can improve the error message or not.