class Class { } const f0 = <T extends typeof Class> (c:T): T => { return c } const call0 = f0 (Class) //ok const f1 = <T extends typeof Class> (c:T): T => { const a = new c() return a //TS2322: Type 'Class' is not assignable to type 'T'. 'T' could be instantiated with an arbitrary type which could be unrelated to 'Class'. } const call1 = f1 (Class) const f2 = <T extends typeof Class> (c:T):InstanceType<T> => { const a = new c() return a //TS2322: Type 'Class' is not assignable to type 'InstanceType '. } const call2 = f1 (Class)Patio de juegos mecanografiado
El argumento se escribe como T, entonces, ¿por qué no es aceptable para el tipo de retorno?
Tu primer fragmento no tiene mucho sentido. Dice que toma algo que es un constructor que devuelve una instancia de Class . Que T extiende new () => Class ;
También dice que devuelve la misma T (un constructor), pero está devolviendo una instancia; eso no tiene sentido
Estabas mucho más cerca en tu segundo fragmento
const f2 = <T extends typeof Class> (c:T): InstanceType<T> => { const a = new c() return a //TS2322: Type 'Class' is not assignable to type 'InstanceType '. } Una vez más, typeof Class se expande a {new() => Class} pero lo que realmente quieres es un constructor genérico, por lo que no puedes simplemente usar typeof Class , tienes que escribir tu propio tipo para el constructor genérico de Class . Entonces su tipo de devolución es mucho más simple.
class Class { a = 1; } class SubClass extends Class { b = 2; } class OtherClass { c = 3; } type ClassCtor<T extends Class> = new () => T; const f = <C extends Class> (c: new() => C): C => { return new c(); } // OR const f = <C extends Class> (c: ClassCtor<C>): C => { return new c(); } // It's a Class instance const call1 = f(Class); // It's a SubClass instance const call2 = f(SubClass); // Fails compilation const call3 = f(OtherClass);Ver ejemplo en vivo