如何在打字稿中专门化泛型类的模板类型？

Question

Is it possible to specialize the template type of a generic class in a generic function in typescript ?

Suppose I have a generic interface and a function which takes the interface constructor as argument:

interface IA<T> {
    func(arg: T)
}

function g<T, IAType extends IA<T>>(
    constructor: { new(): IAType }
): (arg: T) => IAType {
    const ins = new constructor();
    return arg => {
        ins.func(arg);
        return ins;
    }
}

then I provide the class implements IA<T> , which is

class A implements IA<{ key: string }> {
    func(arg: { key: string }) {
        console.log(arg.key);
    }
}

const t = g(A); // type of t is (arg: {}) => A

How can I write the function g or the class A so that function g can specialize the correct template type due to the argument pass in? I want to the final t has the type (arg: {key: string}) => A

Answer 1

This type for constructor parameter for g

 constructor: { new(): IAType }

does not really impose a constraint that func() in IAType must have T as its argument type. The only constraint is IAType extends IA<T> , which means that func in IAType is allowed to have any type as long as it's compatible with func(arg: T) . The inference algorithm probably starts with minimal type which is {} , verifies that func(arg: {}) is compatible with func(arg: T) and just stops there.

Being more strict about constructor type helps:

interface IA<T> {
    func(arg: T): void
}

function g<T, IAType extends IA<T>>(
    constructor: { new(): IA<T> & IAType }
): (arg: T) => IAType {
    const ins = new constructor();
    return arg => {
        ins.func(arg);
        return ins;
    }
}

class A implements IA<{ key: string }> {
    func(arg: { key: string }) {
        console.log(arg.key);
    }
}

const t = g(A); // type of t is (arg: { key: string; }) => A

Both IA<T> & IAType are necessary. If you have only IA<T> , arg type will be inferred as desired, but the return type would be only IA<T> , not A .