Limited Semi-PolyMorphic (LSP) structs?

[Era Scarecrow]

  It just came to mind that what I want is almost more a unioned 
struct. Perhaps this will come up with something closer to what I 
am really looking for.

assuming we could use a union, it would be closer to:

//type is the identifier of which one it's going to be using
union AB {
   iA ia;
   iB ib;

   void A(){}
   void B(){}
   void C(){}
}

struct iA {
   char type;
   void A();
   void C();
}
struct iB {
   char type;
   void A();
   void B();
}

  Now last i checked putting functions calls in unions wasn't 
really a good idea or supported, however we have a problem where 
iA and iB don't know about the union AB, and they will still try 
to call the local struct's data first (or the namespace) before 
anything else. This means if C() get's called, and the type is 
suppose to use iB, then when C() calls A(), it gets iA's A() and 
not iB's A().

  If however we try to do inner structs, then:
struct AB {
   char type;
   iA ia;
   iB ib;

   struct iA {
     void real_A() { //regardless what we call, the outer struct 
gets the calls
       A(); //line 9
       B();
       C();
     }
     void real_C() {
       A();
       B();
       C();
     }
   }

   struct iB {
     void real_A() {
       A();
       B();
       C();
     }
     void real_B() {
       A();
       B();
       C();
     }
   }

   void A() { //calls real_A or real_B
         switch (type) {
             case 'A': ia.real_A();
             case 'B': ib.real_A();
             default: throw new Exception("");
         }
   }
   void B() {
         switch (type) {
             case 'B': ib.real_B();
             default: throw new Exception("");
         }
   }
   void C() {
     ia.real_C();
   }
}

   So far this does seem to want to work, but last I checked I 
thought this was illegal, the reason being the inner structs 
needed a pointer to their outer parent which wasn't a class, at 
which point there was something just difficult about it.

test.d(9): Error: this for A needs to be type AB not type iA
test.d(10): Error: this for B needs to be type AB not type iA
test.d(11): Error: this for C needs to be type AB not type iA
test.d(14): Error: this for A needs to be type AB not type iA
test.d(15): Error: this for B needs to be type AB not type iA
test.d(16): Error: this for C needs to be type AB not type iA
test.d(22): Error: this for A needs to be type AB not type iB
test.d(23): Error: this for B needs to be type AB not type iB
test.d(24): Error: this for C needs to be type AB not type iB
test.d(27): Error: this for A needs to be type AB not type iB
test.d(28): Error: this for B needs to be type AB not type iB
test.d(29): Error: this for C needs to be type AB not type iB

  I recall there being something to help get around this, but a 
delegate didn't seem quite like the right answer...

  I really really don't want to rely on classes, passing a 
reference to the caller may work but adds unnecessary stuff (plus 
you have to explicitly call the referenced rather than having it 
feel like what it should). 'alias this' might help (as with my 
template attempt), but it quickly becomes a chore to keep up 
things and gets ugly fast.

  Mmm..