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

[Stephen Leake <stephen_leake@stephe-leake.org>]

On Monday, December 18, 2017 at 7:01:49 PM UTC-6, Jere wrote:
> 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;

I had a pattern like that in my original SAL library. I provided "Aux" generics to do the helper instantiations in the simple cases, so the typical use case was:

package My_List_Aux is new Sledgehammer_Aux (Item_Type);
package My_Lists is new Sledgehammer (Item_Type, My_List_Aux.Item_Access, My_List_Aux.Deallocate);

I found that to be a good compromise.