www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Type polymorphism and type variance

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?


auto x = gcollection[i]; // x's type is not determined

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.
This seems like a rather inefficient way.

Are there any direct oop ways to do this. If, for example, I make
a wrapper class in which I can create a homogenous array of, but
somehow the wrapper class managed the heterogeneous nature of the
types, then it might work. But it seems to me, no matter how one
tries to make it work, it is impossible(at least efficiently).

In my specific case I am wanting to simply store objects in an
array of the type myObject!T where T could be any type so I can
access functions in the type(which unfortunately depend on the


class myObject(T)
    void SetValue(T v) { }


myObject!?[] arr;     // Not possible
arr[0].SetValue(x)    // But what I am wanting to do.

In fact, I'll have some way to always cast x to the correct
type(or at least, if not, throw an error).

My question:

Is what I've discussed above basically doable with plan old OOP
using some design pattern and not some fancy compiler or
"tricks/hacks"? Basically, am I missing something obvious or is
the problem actually difficult and requires special methods(like
Dec 04 2012