Re: limited agregate and limited components default initialization

[Jere <jhb.chat@gmail.com>]

On Saturday, March 31, 2018 at 11:14:49 PM UTC-4, Jere wrote:
> On Saturday, March 31, 2018 at 10:07:20 PM UTC-4, Jean-Claude Rostaing wrote:
> >    type ITEM_ACCESS;
> >    type Item_Record is limited
> >       record
> >          Item: aliased Item_type;
> >          Next : Item_Access;
> >          Pred : Item_Access;
> >       end record;
> >    package Record_Pointers is new Pointers (Item_type => Item_Record);
> >    type Item_Access is new Record_Pointers.Smart_Pointers;
> 
> Side note:  I couldn't get this to compile because Next and Pred
> are incomplete types (so they too cannot be used a variable types.
> 
> The proper way to do it would be:
>        type Item_Record;
>        package Record_Pointers is new Pointers (Item_type => Item_Record);
>        type Item_Access is new Record_Pointers.Smart_Pointers; 
>     
>        type Item_Record is limited
>           record
>              Item : aliased Item_type;
>              Next : Item_Access;
>              Pred : Item_Access;
>           end record;
> 
> but your Pointers package will need an incomplete formal type for it to
> work:
> 
>     generic
>         type Item_Type(<>);
>     package Pointers is
>         -- stuff
>     end Pointers;
> 
> and that might cause you other problems, but if you want to use
> your smart pointers in a self referential type, you'll need your
> smart pointer generic to use incomplete types.

Since you didn't supply a minimally compilable example, I made a 
quick one stubbing in the things you didn't specify.  Hopefully
this will help give some ideas on what I mean:

procedure jdoodle is

    generic
        type Item_Type(<>);
    package Pointers is
        type Smart_Pointers is limited null record;
    end Pointers;

    generic
       type Item_Type is limited private;
       with function Make_Item return Item_Type;
    package Lists is
       type List_Type is limited private;
       type Item_Accessor (Item: not null access Item_type) is limited private with Implicit_Dereference => Item; 
       
       -- added stub
       type List_Iterator is limited record
            Ref : access Item_Type;
       end record;
       
       function Get(Position: in List_Iterator) return Item_Accessor;
    private
        type Item_Record;
        package Record_Pointers is new Pointers (Item_type => Item_Record);
        type Item_Access is new Record_Pointers.Smart_Pointers; 
    
       type Item_Record is limited
          record
             Item : aliased Item_type;
             Next : Item_Access;
             Pred : Item_Access;
          end record;
          
        -- Added stub
        function Set(value : Item_Record) return Item_Access is (others => <>);
       
        type Item_Accessor (Item: not null access Item_type) is limited record
            REF: ITEM_ACCESS := Set(Item_Record'(Make_Item, others => <>));
        end record;
        
        function Get(Position: in List_Iterator) return Item_Accessor is (Item => Position.Ref, others => <>);
       
       type List_Type is limited record
          First: Item_Access;
          Last : Item_Access;
          Count : Natural := 1;
        end record; 
    end lists;
    
    
    -----------------------------------------------------------
    -- Testing package instantiation
    -----------------------------------------------------------
    type Test is record
        value : Integer := 0;
    end record;
    function Make_Test return Test is (value => 10);
    
    package Test_Lists is new Lists(Item_Type => Test, Make_Item => Make_Test);
begin
    null;
end jdoodle;