Alter method signature for child class in Typescript?

Question

In the example below (Typescript, 1.7+), what would I have to change to allow B.callback to have a different signature than A.callback?

class A {
    callback(result: number) {
    }
}


class B extends A {
    callback(result: number, option: number) {
    }
}

Currently this gives test.ts(7,7): error TS2415: Class 'B' incorrectly extends base class 'A'.

In the real world my example is more complex, but I can dynamically (more or less) guarantee (based on some configuration) that the requested parameters will be there.

Postmistress

Answer 1

Depending on the situation, the following solution may suffice too:

class A {
    callback(result: number) {
    }
}


class B extends A {
    callback(result: number, option?: number) { // make 'option' optional
    }
}

Findley

Answer 2

This will never be allowed. You need to conform to the base class function signature because its polymorphism 101:

class A {
    callback(result: number) {
    }
}


class B extends A {
    callback(result: number, option?: number) {
    }
}

// Reason
var b = new B();
var a:A = b; // okay as its a subclass
a.callback(123); // If b didn't have that optional B.callback can blow up

Otway

Well, yes, but one could argue that any parameter could be undefined at any time nonetheless, so a.callback(123) would still be a valid method call to b. – Postmistress

would still be a valid method call to b Explicitly passing undefined is different from an implicit undefined. And if you find yourself passing an explicit undefined ... please consider making it an optional argument – Otway

Answer 3

I suspect this is not possible in TypeScript 1.6 and the upcoming 1.7. Either give B.callback() a new name, or add the parameter as an optional parameter in A.callback().

It feels kind of wrong from a traditional OOP standpoint, i.e. C#, Java. One should not be able to change the number of parameters in an overridden method. A reference to class A is be able to hold class B objects. If B adds a non-optional parameter to a method, calls to the method via the A reference would fail. This would be raised as an error by the compiler.

Porche

From a traditional standpoint I'm with you. In my example though callback is passed into Angular (as a controller), and dynamically receives a number of parameters based on its configuration (which is set in B's constructor()). – Postmistress

Answer 4

After some back and forth I think the best solution is currently:

class A {
    callback(result: number, ...rest: any[]) {
    }
}


class B extends A {
    callback(result: number, option: number) {
    }
}

Postmistress