something "weird" about polymorphism

[funog]

downs wrote:
> funog wrote:
>> The following code :
>>
>> ------------------
>> import std.stdio;
>> class A {
>>     void foo(A a) {
>>         writefln("A");
>>     }
>> }
>>
>> class B : A {
>>     void foo(B b) {
>>         writefln("B");
>>     }
>> }
>>
>> void main() {
>>     B b = new B;
>>     A a = b;
>>     assert(a is b);
>>     b.foo(b);
>>     a.foo(b);
>> }
>> --------------
>> outputs:
>> B
>> A
>>
>>
>> This is understandable as B.foo doesn't actually overrides A.foo. But
>> somehow it's weird to get different outputs while "a" and "b" are
>> basically the same object. Has anyone else encountered this problem in
>> real life? Will C+++, java act the same way?
>>
> 
> The behavior here is entirely correct and, in fact, could not happen any other way.
> 
> The only improvement would be disallowing declaring methods that shadow but don't override methods in the super class.
> 


This is the point, I think it should be disallowed (particularly in D, 
since shadowing declarations are deprecated). I understand that B.foo 
doesn't override A.foo, but I mean, you have the same object, the same 
function (name), the same parameter... and a different result.
Well, I'm not a pro so I don't know how error-prone it can be in "real 
life".


> The inheritance contract that B enters when it inherits from A states that its foo will take any object of type A. Remember: parameters generalize, results specialize. B's foo _cannot_ override A's foo because that would mean you could not use a B in all situations you could use an A, which breaks polymorphism completely.