I'm admittedly not a D expert, and have not written compilers; but the first
thing that came to my mind is that the second fun() you posted was not an
override, but overload. i.e. the same as the following, except with inheritance
:
print(int a) { /* ... */ }
print(float a) { /* ... */ }
print(string a) { /* ... */ }
Now the main question, IMO, is : how will the compiler differenciate whether
you want to override or overload? Would that change prevent overloading methods
with different signatures?
> Hello,
>
>
> Today, overriding functions have covariant return types:
>
> class A {
> A clone();
> }
>
> class B : A {
> B clone(); // fine, overrides A.clone
> }
>
> That is entirely principled and cool. Now the entire story is that
> overriding function may have not only covariant return types, but also
> contravariant argument types:
>
> class A {
> A fun(B);
> }
>
> class B : A {
> B fun(A); // fine (in theory), overrides A.fun
> }
>
> Today D does not support contravariant arguments, but Walter told me
> once he'd be quite willing to implement them. It is definitely the right
> thing to do, but Walter would want to see a compelling example before
> getting to work.
>
> Is there interest in contravariant argument types? If so, do you know of
> a killer example?
>
>
> Thanks,
>
> Andrei
