Struct polymorphism?

[Era Scarecrow]

  What are the possibilities of struct polymorphism? What would be 
the issues with it? What if we wanted to use it in a limited 
sense?

  Currently I'm experimenting with it since classes are too bulky 
for what I need, yet I really need some type of behavior/dynamic 
polymorphism. So far I have a working model. It takes the 
following limitations:

   1) struct size can't size (no loss of data).
   2) every structure aside from the original needs a copy of the 
original (and only that)
   3) original structure needs an enum specifying behavior mode
   4) Template instantiation cannot be used (although automatic 
type deduction works).


  Using these and limiting it seems like it would sort of bring 
back C++'s design of classes, only better, simpler, and more 
powerful. It won't have an actual full virtual table as 
everything is known statically ahead of time, with only minor 
checks by opDispatch to determine which function set to run.

  Issues:
   1) the base/original struct always calls it's own functions. A 
little work and I can probably remove that limitation, but the 
original struct would end up being only storage with no behavior 
at all.
   2) Template instantiation. This is a limitation in opDispatch() 
where calling through it. As shows below. Maybe I'm just using 
opDispatch wrong.

//signatures lacking structs
auto ref opDispatch(string fun, Args ...)(auto ref Args args) 
@property;
I templateType2(string val1, I)(I val);


//call
ps.templateType2!"Extra Extra!"(50);

Error: ps.opDispatch!("templateType2") isn't a template


  Beyond this it seems to have some potential. Thoughts? Ideas?