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

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

On Sunday, December 17, 2017 at 10:39:17 AM UTC-5, Dmitry A. Kazakov wrote:
> On 2017-12-17 16:26, Jere wrote:
> 
> > my assertion is that:
> > 
> >     subtype Thing is Core_Pkg.Thing;
> > 
> >     procedure Do_Something(The_Thing : in out Thing)
> >        renames Core_Pkg.Do_Something;
> >         
> > 
> > is easier to both maintain and read than:
> > 
> >     type Thing is new Core_Pkg.Thing with null record;
> >     
> >     procedure Do_Something(The_Thing : in out Thing);
> 
> But these are two semantically different concepts. Ada's subtype 
> declares an equivalent type [it inherits everything from and exports 
> everything to the base]. Ada's new tagged type declares a new instance 
> of a class. It only inherits.
> 
> I don't understand how can you exchange one for another.
> 
> -- 
> Regards,
> Dmitry A. Kazakov
> http://www.dmitry-kazakov.de

I don't want to exchange one for the other.  I have a package that I want
to provide default arguments to privately but maintain the same exact 
type/operation specification.  Subtyping seems more correct than
inheritance in this case.  I'm not trying to define a new type or an
extension of a type.  I just want provide a simpler interface to a
much more complex generic while hiding part of that so the user doesn't
accidentally do something they shouldn't. 

Something like:

generic
   type Item_Type(<>);
   type Item_Access is access Item_type;
   with procedure Deallocation(Ref : in out Item_Access);
package Sledgehammer is
   <types>
   <operations>
private
   <implementation>
end Sledgehammer;

This would be used in maybe 5% or less of the code base and only
when absolutely necessary.  I want to convert it to:

generic
   type Item_Type(<>) is limited private;
package Nicer_Package is
   type Item_Access is access Item_Type;
   <same types>
   <same operations>
private
   procedure Deallocate is new Ada.Unchecked_Deallocation
      (Item_Type,Item_Access);

   package Implementation is new Sledgehammer
      (Item_Type => Item_Type,
       Item_Access => Item_Access,
       Deallocation => Deallocate);

   <implementation>
end Nicer_Package;

Since all I am doing is automating the access type and
the deallocation operation, I don't think a new type
is really the right design. Additionally, I don't want
to expose the deallocation operation as it should never
be called directly.

Based on earlier conversion from Jeff, it looks like
composition is my best bet since I cannot do it via
subtyping and renames.  I was just hoping there was a
way I could do it without adding so much extra stuff
to read and maintain.  I don't like decreasing 
readability like that.  If I am willing to expose the
deallocation operation, then I can just use subtype
and renames (which make more sense to me in this
case) but that's the tradeoff.