Re: Building limited types through nested creator functions

[Shark8 <onewingedshark@gmail.com>]

On Feb 5, 4:03 pm, Simon Belmont <sbelmont...@gmail.com> wrote:
> Hi,
>
> Consider two limited record types, inner and outer, with the former
> nested inside the latter.  If the records are public, then code can
> initialize the outer by specifying an aggregate for the inner, as in:
>
> type Inner is limited
>   record
>     e : Integer;
>   end record;
>
> type Outer is limited
>   record
>     i : Inner;
>   end record;
>
> o : Outer := Outer'(i => Inner'(e => 42));
>
> However, if types are made private, suitable functions must be
> provided to make the appropriate objects.  If just Inner is private,
> then this can be done (assuming simple creator functions that just
> create the objects with the given values):
>
> o : Outer := Outer'(i => Make_Inner(arg => 42));
>
> but if both are private, then the following:
>
> o : Outer := Make_Outer (arg => Make_Inner(arg => 42));
>
> ends up being illegal, because in the code:
>
> function Make_Outer (arg : Inner) return Outer is
> begin
>   return Outer'(i => arg);
> end Make_Outer
>
> would end up trying to copy a limited type.  For the cases in which an
> existing object is passed in, this would be the appropriate action,
> but for cases where the object is built-in-place into the argument,
> clearly the intended behavior is to build it in place to the resultant
> object.  It's easy enough to use an access value, but as unnecessary
> use of access values is generally discouraged, I was just curious if
> there was an alternative mechanism to achieve the desired effect.
>
> -sb

Try this:

Function Make_Inner( I: Integer ) Return Inner is
begin
    Return Result : Inner:= Inner'( E => I );
end Make_Inner;

Function Make_Outer( I: Integer ) Return Outer is
begin
    Return Result : Outer:= Outer'( I => Make_Inner(I) );
end Make_Outer;

The 'trick' is to use all the parameters used in make_inner plus
whatever is needed in the Outer record for the parameter-list of
Make_Outer; thus you avoid all copying restrictions as you are really
building-in-place.