Contravariance (is this a bug)

[Norbert Nemec]

In fact, the code contains a bug inside the A_Parser.get function which 
implicitely converts stuff from type Report to type A_Report. If you 
change the declaration of stuff to
	A_Report[string] stuff;
everything should be fine.

Furthermore, your comments seems to confuse the terms co- and 
contra-variance. The interface of of A_Parser.get does in fact 
demonstrate "co-variance": output types of overriding methods must be 
subtypes of the original methods output. (They have the same direction 
of inheritance as the enclosing class, hence "co-")

Input type, on the other hand are "contra-"variant. An overriding method 
must accept as input any *super*-type of input types of the original.

Greetings,
Norbert


On 26/07/10 17:46, Jesse Phillips wrote:
> Contravariance allows derived classes to return from a function any derived class of what the parent class returns. I have discovered that if you claim to return a derived class, you can still return the parent class. In the example below, A_Parser is returning Report[] from a function that claims to return A_Report[]. I'm thinking this is a bug, is there any reason it wouldn't be?
>
> import std.stdio;
>
> class A_Parser : Parser {
>     Report[string] stuff;
>
>     this() {
>        stuff = ["hi": new A_Report("Bye")];
>     }
>
>     override A_Report get(string uuid) {
>        return stuff[uuid];
>     }
> }
>
> class A_Report : Report {
>     string value;
>     this(string val) {
>        value = val;
>     }
>
>     void print() {
>        writeln(value);
>     }
> }
>
> abstract class Parser {
>     abstract Report get(string);
> }
>
> class Report {
> }
>
> void main() {
>     auto a = new A_Parser();
>
>     a.get("hi").print;
>
> }
>