Generic Type Alias Overloading

[erichiller]

Search Terms

• variadic type alias
• Generic variadic Type Alias
• Generic Overload
• Generic Type Alias Overloading

Suggestion

Ability to either:

• overload generic type definitions
  or
• define variadic type parameters for generic type aliases. (not sure how this would work)

Use Cases

My specific, immediate need is to create a generic variable number of input type alias for Intersection. I could see other use cases though, and imagine others would find it useful.

The closest work around is if I define default type parameters, like:

type Intersection<A, B, C = {} , D = {}, E = {}, F = {}> = A & B & C & D & E & F;

// and use like
let foo: Intersection<{ prop1: number}, {prop2: string}>;

// it evaluates to
{ prop1: number } &
{ prop2: number } &
{ } &
{ } &
{ } &
{ }

Examples

With overloads, the above type could be declared like:

type Intersection<A , B> = A & B;
type Intersection<A , B , C> = A & B & C;
type Intersection<A , B , C , D> = A & B & C & D;
type Intersection<A , B , C , D , E> = A & B & C & D & E;
type Intersection<A , B , C , D , E , F > = A & B & C & D & E & F;

I am not sure of a good syntax for the variadic type, it also seems like it would have a more limited use.

Checklist

My suggestion meets these guidelines: ( I think )

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

[RyanCavanaugh]

I absolutely know we had a couple meetings about this in the past, but can't find notes for it, so we'll talk about it again 🙃

[ecyrbe]

could i suggest using c++ like syntax for variadic templates? :

type intersection<T, U...> = T &... U;
type union<T, U...> = T |... U;
type template <T, U...> = `${T}$...{U}`