TypeScript compiler not enforcing type parameter in implementation of generic interface?

Question

Consider a TypeScript interface with two implementations:

interface IFoo {}

class FooA implements IFoo {}
class FooB implements IFoo {}

Next, consider a generic interface that accepts an implementation of IFoo as type parameter:

interface IFooHandler<F extends IFoo> {
    handle(foo: F): string
}

Now, let's implement the IFooHandler interface with a specific implementation of IFoo as a type parameter:

class FooAHandler implements IFooHandler<FooA> {
    handle(foo: FooB): string {
        return "Hello, Foo A!";
    }
}

This compiles perfectly, using tsc in version 2.0.3. So here's my question: Why does this compile?

Note that I've used FooB as parameter type in the FooAHandler's handle() function. I would assume that this code would trigger a compiler error, as the IFooHandler<F> interface prescribes that the handle method should accept a parameter of type F (so, in case of a IFooHandler<FooA>, of type FooA -- and not FooB).

I could not find anything on this behaviour in the TypeScript documentation. Is this behaviour intentional, and if so, what's the reasoning behind it? Or am I just using this feature the wrong way?

Just for comparison, implementing the exact same example in Java (omitting the code, as it's quite similar) yields the (expected) compile error:

FooAHandler.java:1: error FooAHandler is not abstract and does not override abstract method handle(FooA) in IFooHandler

This is discussed several times in the FAQ - github.com/Microsoft/TypeScript/wiki/… and github.com/Microsoft/TypeScript/wiki/… and — Ryan Cavanaugh
– Ryan Cavanaugh, Commented Oct 24, 2016 at 19:52
Also basically a duplicate of stackoverflow.com/questions/32106253/… — Ryan Cavanaugh
– Ryan Cavanaugh, Commented Oct 24, 2016 at 19:53
@RyanCavanaugh, thanks for the link. Ouch, I cannot believe that I missed the literally first question in the FAQ. Anyhow, this behaviour makes more sense to me now! Thanks for your comment. — helmbert
– helmbert, Commented Oct 24, 2016 at 20:04

Nitzan Tomer · Accepted Answer · 2016-10-24 19:52:30Z

6

This happens because the compiler doesn't compare the types by name, it checks their structures, and since IFoo, FooA and FooB are all empty then they are all equal.

Even when doing:

interface IFoo {
    a: string;
}

class FooA implements IFoo {
    a: string;
}

class FooB implements IFoo {
    a: string;
}

The compiler still won't complain, but once we differentiate between FooA and FooB:

class FooA implements IFoo {
    a: string;
    b: string;
}

class FooB implements IFoo {
    a: string;
    c: string;
}

We get the compiler error:

Class 'FooAHandler' incorrectly implements interface 'IFooHandler<FooA>'.  
  Types of property 'handle' are incompatible.  
    Type '(foo: FooB) => string' is not assignable to type '(foo: FooA) => string'.  
      Types of parameters 'foo' and 'foo' are incompatible.  
        Type 'FooA' is not assignable to type 'FooB'.  
          Property 'c' is missing in type 'FooA'.

(code in playground)

A side note:
Empty objects (like all of your interfaces) will always accepts everything:

interface IFoo { }

function fn(foo: IFoo) {}

fn(3); // ok
fn("string"); // ok
fn({ key: "value" }); // ok

(code in playground)

answered Oct 24, 2016 at 19:52

Nitzan Tomer

166k51 gold badges330 silver badges307 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

helmbert Over a year ago

+1, great answer, thanks! I may have actually oversimplified my example, as my actual interfaces of course aren't all empty, but this answer got me on the right track.

Kir Over a year ago

Is there a way to get the originally-expected behavior though?

Nitzan Tomer Over a year ago

@Kir what's the "originally-expected behavior"? If you mean that you want the compiler to compare types by their declared types other than their structure, then no, this is just how the ts compiler works.

Collectives™ on Stack Overflow

TypeScript compiler not enforcing type parameter in implementation of generic interface?

1 Answer 1

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related