casts / wildcards for parametrized types

[Ali Çehreli]

On 08/01/2013 04:28 PM, tx wrote:

 > Hi All,
 > Hoping somebody can provide some help here, I have a set of classes
 > that are similar to the following
 >
 > class Item{}
 >
 > class Box(T) : Item {
 >    T value;
 >    //  ...
 > }
 >
 > //Along with some aliases:
 >
 > alias Box!(long) LongBox;
 > alias Box!(char) CharBox;
 > //etc.
 >
 >
 >
 > I'd like to have a function that operates on instances of Item, but I
 > want to specialize the behavior to handle instances of Box
 > differently. Is there anyway I can upcast Item to Box without
 > specifying the type parameter? In my case I don't really care about
 > what T is, just that I'm working with a Box of something. Currently I
 > have a whole if-else ladder checking to see if I'm working with an
 > instance of each of the aliases and casting appropriately, but I would
 > prefer to just write that once. I guess I'm looking for something like
 > cast(Box). Is this possible?
 >
 > To put it another way, is there a D equivalent to the Java syntax of 
Box<?>

Inserting another layer to the hierarchy is a solution. ConcreteBox is 
the same as your Box and the new Box in a non-template intermediate class:

class Item{}

class Box : Item{}

class ConcreteBox(T) : Box {
   T value;
   //  ...
}

alias ConcreteBox!(long) LongBox;
alias ConcreteBox!(char) CharBox;
//etc.

// Explicit check
int foo(Item item)
{
     if (cast(Box)item) {
         return 1;
     }

     return 0;
}

unittest
{
     assert(foo(new Item()) == 0);
     assert(foo(new LongBox()) == 1);
     assert(foo(new CharBox()) == 1);
}

// Automatic dispatch for compile-time binding
class Foo
{
     int foo(Item item)
     {
         return 0;
     }

     int foo(Box box)
     {
         return 1;
     }
}

unittest
{
     auto f = new Foo();
     assert(f.foo(new Item()) == 0);
     assert(f.foo(new LongBox()) == 1);
     assert(foo(new CharBox()) == 1);
}

void main()
{}

Ali