Distribute union types over generic function application

[matthewvalentine]

Suggestion

🔍 Search Terms

generic union distribute function mapped

✅ Viability Checklist

My suggestion meets these guidelines:

• [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
• [x] This wouldn't change the runtime behavior of existing JavaScript code
• [x] This could be implemented without emitting different JS based on the types of the expressions
• [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• [x] This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

It should be possible to call a generic function with a union as input and separately resolve the generics for each member of the union. This mimics the way generic types can be distributed over a union.

📃 Motivating Example

Consider this simple example (playground):

type A<T> = (a: T) => T; // any type invariant on T
function foo<T>(a: A<T>) {}
declare const a: A<1> | A<2>;
foo(a); // error: A<1> | A<2> is not assignable to A<1 | 2>

The function foo is perfectly capable of handling an input of either A<1> or A<2>, but Typescript will not allow you to execute it on the union of those types. That is because it tries to find a single instantiation for T that works, but there is none, because the type A<T> is not covariant.

In the case that foo had an output, foo: <T>(a: A<T>) => B<T>, for input of A<1> | A<2> the output type would be B<1> | B<2>, much the same as how distributing over a union works in a type expression like X extends A<infer T> ? B<T> : never;

💻 Use Cases

This is one of a few issues that make non-covariant types a little bit second-class to work with in Typescript. And some of the other issues might be very hard to resolve, like how to type "An array of A<T> where each element can have a different T" without using any. But in comparison, I don't think this one requires any deep thought for the desired behavior, and while the implementation might be tricky I don't think it requires any truly new capabilities.

Workarounds:

1. For a function where T doesn't appear in the output, like <T>(a: A<T>) => void, can be typed as (a: A<any>) => void. Then it works with unions as input. However, that introduces anys into the typechecking of the function's implementation, which don't need to be there. Instead, you can explicitly specify foo<any>(x) when calling the function. But if the function has other generics, that will make it so they also have to be explicitly specified instead of inferred.
2. For a function where T does appear in the output, like <T>(a: A<T>) => B<T> where A<T> and B<T> are both invariant, I am not aware of any workaround except casting. Using any leaks into the output type and therefore the rest of your code. Even casting in that situation is more brittle than usual, as changes to the input union type or to the definition of the function's output type will both be lost.

[RyanCavanaugh]

I'd be extremely worried about this happening in practice. Unions regularly contain hundreds of members, and resolving a generic function call is not a cheap operation. Worse, if a union appears in the output, then this is very prone to combinatorial explosion. A codebase full of calls like this could take minutes or hours to check (or just run out of memory).

[matthewvalentine]

@RyanCavanaugh That makes sense. Though I'd have thought type operators using extends should have the same possible issues. What has made it ok there - is it that it's opt-in via the extends clause, or just that there are fewer usages of type operators than generic functions?

As for performance, it might not have to be implemented as actually doing a separate resolution for each member of the union. Currently, if you call foo(A<1> | A<2>), TS gets as far as inferring that T = 1 | 2. That inference doesn't actually work, but there's clearly something in the resolution already that is seeing the relationship between A<1> | A<2> and A<T>. And it resolves it in a way that works for covariant types. At that same moment, it might be possible to see that since A is not covariant, it should be resolved in a different way instead.

[whzx5byb]

You can distribute the union explicitly as a workaround:

type A<T> = (a: T) => T; // any type invariant on T
function foo<T>(a: T extends unknown ? A<T> : never) {
}
declare const a: A<1> | A<2>;
foo(a); // ok

[OliverJAsh]

You can distribute the union explicitly as a workaround:

Unfortunately this doesn't work if the parameters are objects:

type AR = { a: string };
type BR = { b: string };
type A<T> = (a: T) => T; // any type invariant on T
function foo<T>(a: T extends unknown ? A<T> : never) {}
declare const a: A<AR> | A<BR>;
foo(a); // error