Re: limited agregate and limited components default initialization

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

On Tuesday, April 3, 2018 at 2:18:18 PM UTC-4, Jean-Claude Rostaing wrote:
> Talking about limited aggregates, how to make the exemple below with protected types work ? It should be pretty much the same as what I already did, yet...
> package P is
>    type Essai (<>) is limited  private;
>    function Constructor (v: Natural) return  ESSAI;
>    procedure CHANGE (Obj: Essai; V: Natural);
> private
>    protected type ESSAI (D1: Natural) is 
>       procedure CHANGE (V: Natural);
>    private
>       Private_var: Natural := D1; 
>    end Essai;
> end P;
> 
> package BODY P is
>    -- procedure change(Obj: Essai; V: natural) renames ESSAI.CHANGE;
>    procedure CHANGE (Obj: ESSAI; V: NATURAL) is
>    begin
>       OBJ.CHANGE(V); -- 5
>    end CHANGE;
>    function CONSTRUCTOR ( V : NATURAL) return ESSAI is
>      (Essai(D1 => V)); -- 9
> 
>    protected body Essai is
>       procedure CHANGE (V: natural) is
>       begin
>          PRIVATE_VAR := V;
>       end change;
>    end Essai;
> end P;
> 
> I get
> p.adb:5:10: prefix of protected procedure or entry call must be variable
> p.adb:9:14: invalid prefix in call
> 
> Actually, I wanted CHANGE to be a renaming of Change, but since Essai here behave more like a package, the protected operation doesn't its protected object as an argument, so the profile wouldn't be the same, so a renaming can only point to a specific task/protect object's entry.
> 
> I want to force people to use a constructor on any object of ESSAI type through setting its discriminants. Discriminants who would serve to set the default value with the constructor, so they must be hidden from the user.
> 
> I must confess I never used anything protected types before... I thought the use would be more intuitive ?

As an alternative.  If you end up needing to handle protected types without
discriminants, you can use a private implementation type and composition:

    package P is
       type Essai (<>) is limited private;
       function Constructor (v: Natural) return ESSAI;
       procedure CHANGE (Obj: in out Essai; V: Natural) with Inline;
    private
    
       -- Internal implementation type
       protected type ESSAI_Impl  is
          procedure CHANGE (V: Natural);
       private
          Private_var: Natural := 0;
       end Essai_Impl;
       
       -- new wrapper type
       type Essai is limited record
          Impl : Essai_Impl;
       end record;
    end P;
    
    package BODY P is
    
       procedure CHANGE (Obj: in out ESSAI; V: NATURAL) is
       begin
          OBJ.Impl.CHANGE(V); -- 5
       end CHANGE;
       
       function CONSTRUCTOR ( V : NATURAL) return ESSAI is
       begin
          -- Can use aggregate to create the wrapper type
          return Result : Essai := (others => <>) do
             Result.Impl.CHANGE(V);  --now initialize the value
          end return;
       end CONSTRUCTOR;
    
       protected body Essai_Impl is
       
          procedure CHANGE (V: natural) is
          begin
             PRIVATE_VAR := V;
          end change;
          
       end Essai_Impl;
       
    end P;