Type checking and generics

Question

Let's say I have an interface:

interface Comparable<T> {
    equals(other:T):boolean
}

Which then I'm implementing in several classes:

class Rectangle implements Comparable<Rectangle> {

    equals(other:Rectangle):boolean {
        // logic
        return true;
    }

}

class Circle implements Comparable<Circle> {

    equals(other:Circle):boolean {
        // logic
        return true;
    }

}

Why TypeScript allows for comparing rectangle and circle?

let circle:Circle = new Circle();
let rectangle:Rectangle = new Rectangle();
console.log( circle.equals(rectangle) );

Shouldn't it warn me that I provided incompatible type to circle's equals method?

Answer 1

Like JavaScript, TypeScript uses duck typing. So in your example rectangle and circle are identical.

Once these classes add their own implementations the duck typing will fail and the TypeScript compiler will give you errors.

class Rectangle implements Comparable<Rectangle> {

     width: number;
     height: number;

     equals(other:Rectangle): boolean {
         // logic
         return true;
     }

}

class Circle implements Comparable<Circle> {

    diameter: number;

    equals(other:Circle): boolean {
         // logic
         return true;
     }

 } 

Answer 2

Because your Rectangle and Circle are structurally identical, TypeScript treats them as interchangable types (see "duck typing"). Just flesh out your circle and rectangle by adding some mutually incompatible properties to them:

class Rectangle implements Comparable<Rectangle> {
    x: number;
    equals(other:Rectangle):boolean {return true;}
}
class Circle implements Comparable<Circle> {
    rad: number;
    equals(other:Circle):boolean {return true;}
}

And you'll see the error show up. This is, incidentally, the same reason that you can assign an object literal to a Circle-typed var, as long as it has the right properties:

var c: Circle = {rad: 1, equals: () => true}