TypeScript：是否可以强制接口签名中的泛型类型与实现此接口的 class 类型相同

Question

I want to force a declared generic in a signature of the interface be of the same type of the class that implements this interface. Something like the below code:

interface I1<T = typeof this> {

    aAnyMethod(): I1<T>;

}

class C1 { }

class C2 implements I1<C1> /* accepts C1 but shouldn't, it should only accept C2 */ {

    // ok. It works as it should
    aAnyMethod(): C2 {
        return new C2;
    }

}

class C3 implements I1{

    // not accepted. It works as it should
    aAnyMethod(): C1 {
        return new C1;
    }

}

Answer 1

You can give the type parameter a self-referential upper bound. This is a standard solution to this problem, used eg in Java's interface Comparable<T extends Comparable<T>> .

interface MyInterface<T extends MyInterface<T>> {
    someMethod(): T;
}

class Works implements MyInterface<Works> {
    someMethod() { return new Works(); }
    foo() { return 'foo'; }
}

// error: Type 'SomethingElse' does not satisfy the constraint 'MyInterface<SomethingElse>'.
class DoesntWork implements MyInterface<SomethingElse> {
    someMethod() { return new SomethingElse(); }
}

Unfortunately, something like this will still work:

// No error, because Works extends MyInterface<Works>
class ShouldntWorkButDoes implements MyInterface<Works> {
    someMethod() { return new Works(); }
    baz() { return 'baz'; }
}

However, this doesn't cause a problem because anywhere you want to accept something implementing MyInterface , you can require that it implement MyInterface<...> of itself:

function acceptsMyInterface<T extends MyInterface<T>>(arg: T) {}

// OK
acceptsMyInterface(new Works());

// error: Argument of type 'ShouldntWorkButDoes' is not assignable to parameter of type 'MyInterface<ShouldntWorkButDoes>'.
acceptsMyInterface(new ShouldntWorkButDoes());

So then ShouldntWorkButDoes only works where it is declared, not where it is used. (Note that for the purpose of this demonstration, I had to add some members foo and baz so that Typescript doesn't treat these types as structurally equivalent .)

Playground Link