Re: contravariant argument types: wanna?

[Jeremie Pelletier]

Andrei Alexandrescu wrote:
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

I can't think of an use for contravariant parameters, since a B is 
guaranteed to always be a A, I don't see the point of being able to 
declare fun(A).

However, I would love to hear about covariant parameters, it would be 
most useful for interface implementations:

interface A {
        A fun(A);
}
class B : A {
        B fun(B);
}
class C : A {
        C fun(C);
}

Currently you need some pretty boring boilerplate code, which isn't 
complicated but gets repetitive when you have hundreds of such cases:

class B : A {
        B fun(A) {
                if(B b = cast(B)b) // do stuff
                else throw Error("Invalid object type");
        }
}

Jeremie