Are mutually dependant and possibly recursive types using Containers possible?

Are mutually dependant and possibly recursive types using Containers possible?

[Shark8]

Alright, let's say we're implementing a programming a programming language  -- because the problem becomes very apparent there -- and it has a simple set of two primitive types, Real and Integer, and two complex ones, Array and String.

If it were just the primitive-types, we could use:
 Type Primitive(Is_Real : Boolean) is record
    case Is_Real is
        when True  => Real_Value    : Float;
        when False => Integer_Value : Integer;
    end case;
 end record;


We could add Strings easily enough:
 Package String_Holder is new Ada.Containers.Indefinite_Holders( String );
 
 Type Type_Indicator is ( TI_Integer, TI_Real, TI_String );
 
 Type Item( Indicator : Type_Indicator ) is record
    case Indicator is
        when TI_Integer => Integer_Value : Integer;
        when TI_Real    => Real_Value    : Float;
        when TI_String  => String_Value  : String_Holder.Holder;
    end case;
 end record;

But with adding arrays things break down:
we can't instantiate Ada.Containers.Indefinite_Vectors for use in Item because Item isn't defined at that point, yet we absolutely need it in order to make it (the structure/definition) simple.

True, we could avoid this if arrays of arrays aren't required/allowed, but the problem comes back if the language introduces/requires references and, arguably, pointers. (The difference being that the empty-holder would not be allowed in a reference, but would in a pointer [whose null value would be the no_element constant].)

Re: Are mutually dependant and possibly recursive types using Containers possible?

[Jeffrey R. Carter]

On 09/09/2016 01:24 PM, Shark8 wrote:
> 
> We could add Strings easily enough:
>  Package String_Holder is new Ada.Containers.Indefinite_Holders( String );
>  
>  Type Type_Indicator is ( TI_Integer, TI_Real, TI_String );
>  
>  Type Item( Indicator : Type_Indicator ) is record
>     case Indicator is
>         when TI_Integer => Integer_Value : Integer;
>         when TI_Real    => Real_Value    : Float;
>         when TI_String  => String_Value  : String_Holder.Holder;
>     end case;
>  end record;
> 
> But with adding arrays things break down:
> we can't instantiate Ada.Containers.Indefinite_Vectors for use in Item because Item isn't defined at that point, yet we absolutely need it in order to make it (the structure/definition) simple.

Somebody named Shark8 asked this July 30:

https://groups.google.com/forum/#!msg/comp.lang.ada/Brf7vvOLvrQ/fQB6RUzZAgAJ;context-place=forum/comp.lang.ada

I'm not sure what was wrong with the solution you got there then, since you
didn't respond to any of the replies, but my solution is still to make Item a
type extension of a dummy tagged type Root, and instantiate Indefinite_Vectors
with Root'Class.

-- 
Jeff Carter
"In the frozen land of Nador they were forced to
eat Robin's minstrels, and there was much rejoicing."
Monty Python & the Holy Grail
70