Re: Type polymorphism and type variance

[Lubos Pintes]

Sorry maybe I am stupid but where is the value of concrete T?
Or perhaps I completely misunderstood this?
Dňa 5. 12. 2012 4:59 Ali Çehreli  wrote / napísal(a):

On 12/04/2012 06:42 PM, js.mdnq wrote:
 > One thing I've always struggled with in oop is how to deal with
 > storing generic types.
 >
 > A very simple example is, suppose you had to design a way to
 > store generic types.
 >
 > class myGtype(T) { }
 >
 > ...
 >
 > myGType[] gcollection; // should store various types such as
 > myGtype!int, myGtype!myobj, etc.., possibly even other things
 > like myotherobj, etc..
 >
 > Obviously we can't store different types in a homogenous array.
 > I know D has the ability to use variant types that basically
 > overcome this. I imagine it is very inefficient to do it this way?
 >
 > In my mind, it seems like one could never get around the issue
 > without storing type information along with the data because the
 > compiler will eventually need to know the type information to
 > know how to deal with the data?
 >
 > e.g.,
 >
 > auto x = gcollection[i]; // x's type is not determined

What do you expect to do with x? Unless there is a common interface the
compiler cannot compile the code without knowing the type of x.

Note that even myGtype!int and myGtype!double are completely different
types with completely different capabilities.

 > auto x = cast(myGtype!int)gcollection[i]; // x's type is forced
 > to be myGtype!int, but may not be if gcollection is heterogeneous.
 >
 > If we stored type information along with the data then we could
 > use it to cast to the correct type and make the compiler happy.

Alas, the compiler is not available at runtime.

 > Are there any direct oop ways to do this.

The easiest way in OOP would be interfaces and polymorphism. The myGtype
class template below implements the MyInterface interface and it enables
us to put different types of objects in a collection.

import std.stdio;

interface MyInterface
{
     void foo();
     MyInterface dup();
}

class myGtype(T) : MyInterface
{
     void foo()
     {
          specialOperationFor!T();
     }

     myGtype dup()
     {
         return new myGtype();
     }
}

void specialOperationFor(T : double)()
{
     writefln("Special operation for %s", T.stringof);
}

struct S
{
     int i;
}

void specialOperationFor(T : S)()
{
     writefln("Special operation for %s", T.stringof);
}

void main()
{
     MyInterface[] objects;

     objects ~= new myGtype!double();
     objects ~= new myGtype!int();
     objects ~= new myGtype!S();

     foreach (o; objects) {
         o.foo();
     }

     // We can even copy them and the copies have the correct types:
     foreach (i, o; objects) {
         auto c = o.dup();
         writefln("Using the copy of item %s", i);
         c.foo();
     }
}

The output:

Special operation for double
Special operation for int
Special operation for S
Using the copy of item 0
Special operation for double
Using the copy of item 1
Special operation for int
Using the copy of item 2
Special operation for S

Ali