Variadic generic types in TypeScript?

Question

I'd like to make a function in TypeScript that takes an array of constructor functions and returns a corresponding array of instances. See code below.

Note that the getArray method is wildly incorrect, it is just an attempt to convey my intent.

Is this possible in any form or is it beyond the capabilities of TypeScript's type engine?

class T1 {}
class T2 {}
class T3 {}
type AnyCon = new() => any;

function getOne<T_Con extends AnyCon>(con: T_Con): InstanceType<T_Con> {
  return new con();
}

function getArray<T_Cons>(cons: T_Cons): InstanceType<T_Cons>[] {
  return cons.map( (c: con) => new con() );
}

let t1: T1 = getOne(T1);
let [t2, t3]: [T2, T3] = getArray( [T2, T3] );

Answer 1

You can do this in TS3.1 and above using mapped array/tuple types. It's a little easier to get tuples inferred for rest parameters than it is for array parameters, so I'll show that instead:

function getVariadic<T extends Array<AnyCon>>(...cons: T): {
  [K in keyof T]: T[K] extends AnyCon ? InstanceType<T[K]> : never
};
function getVariadic(...cons: AnyCon[]): any[] {
  return cons.map((c: AnyCon) => new c());
}

let [t2, t3]: [T2, T3] = getVariadic(T2, T3);

Edit: Since TypeScript 4.0 introduced variadic tuple types you can also get the compiler to infer tuple types from arrays passed in:

function getArray<T extends Array<AnyCon>>(cons: [...T]): {
    [K in keyof T]: T[K] extends AnyCon ? InstanceType<T[K]> : never
};
function getArray(cons: AnyCon[]): any[] {
    return cons.map((c: AnyCon) => new c());
}

let [t2, t3]: [T2, T3] = getArray([T2, T3]);

Note how the cons parameter is of variadic tuple type [...T], which gives a hint to the compiler to infer that [T2, T3] is a tuple instead of an unordered array.

Playground link to code