Re: Full view of a private partial view cannot be a subtype

["Randy Brukardt" <randy@rrsoftware.com>]

"Jere" <jhb.chat@gmail.com> wrote in message 
news:c6ba70e3-bfd0-42ca-b742-dc472965eea0@googlegroups.com...
...
>   package New_Type1 is
>      subtype Instance is Base.Instance;
>      procedure Operation(Object : in out Instance);
>
>   private
>
>      procedure Operation(Object : in out Instance) renames Base.Operation;
>   end New_Type1;
>
> (NOTE:  is there a better way to do this?)

No, no better way yet, but maybe (large maybe here) in Ada 2020. (I'm 
leaving out all details because none have been determined yet and perhaps 
never will be for Ada 2020.)

> This is all well and good, but sometimes while I as an implementer
> want this kind of relationship, I don't necessarily want to expose
> that relationship outside the private section of a package.  Here I
> run into a problem as I cannot (as far as I can tell) do:
>
>   package New_Type2 is
>      type Instance is tagged limited private;
>      procedure Operation(Object : in out Instance);
>   private
>      subtype Instance is Base.Instance;

This is illegal; a private type has to be completed with a full type, not a 
subtype. (If you have a compiler that is allowing this, it is confused...)

>      procedure Operation(Object : in out Instance) renames Base.Operation;

...which makes Instance a different type, and that makes this illegal (if 
the type declaration is written properly).

>   end New_Type2;

Usually, you're better off allowing the relationship between types to be 
visible. In that case, this happens automatically.

Otherwise, you can usually do this with this a "squirreling" rename 
(essentially, you have to rename the inherited entity before declaring the 
new one). However, in this case, you've hidden the inherited operation 
before you can rename it, so you can't do this. If you wanted a different 
operation name, it would work:

   package New_Type3 is
      type Instance is tagged limited private;
      procedure Other_Operation(Object : in out Instance);
  private
      type Instance is new Base.Instance with record ... end record;

     procedure Other_Operation(Object : in out Instance) renames 
Operation; -- (1)

  end New_Type3;

At (1), you are renaming the operation inherited from Base.Instance. That 
operation isn't visible to clients, only within this package. And it has the 
correct types.

The main use for a "squirrelling" rename is to be able to call the original 
operation in a overridden operation:

   package New_Type4 is
      type Instance is new Base.Instance with record ... end record;
      -- Operation is inherited here, with the profile:
      --procedure Operation (Object : in out Instance);
  private

     procedure Original_Operation(Object : in out Instance) renames 
Operation; -- (1)
     overriding
     procedure Operation (Object : in out Instance);
  end New_Type4;

The declaration at (1) allows the body of Operation to call the body of 
Base.Operation (but with the proper types).

                           Randy.