Re: Extending a third party tagged type while adding finalization

[Shark8 <onewingedshark@gmail.com>]

On Sunday, November 26, 2017 at 10:33:50 AM UTC-7, Jere wrote:
> 
> What I tried to do was use a mixin but have it keep a reference to a
> classwide access on the object.  Then I tried dispatching out to the
> correct object type from there.  This kind of highlighted the evils
> of using redispatch in Ada though as I found that if I had component
> definitions like this:

JP Rosen's paper "A Naming Convention for Classes in Ada 9X" details a way you might be able to ease the pain of such constructs. 

The example of adding a "with benefits" extension to "computer scientist" which is itself an "employee" is detailed as follows:
with Employee; use Employee;
generic
     type Origin is new Employee.lnstance with private;
packaqe With_Benefits_Facet is
    type Instance is new Origin with private;
    subtype Class is Instance'Class;
    
    -- Operations to handle benefits private 
end With__Benefits_Facet;

--------------------------------

with Computer__Scientist, With_Benefits_Facet; use Computer_Scientist;
package Computer_Scientists__With__Benefits is
     new With__Benefits__Facet(Computer_Scientist. Instance); 


So, to do this sort of thing how you want, couldn't you handle things via generic?

Generic
  -- You might want to put a Base here and derive from it...
  Type Controlled is limited private;
  with procedure Initialize (Object : in out Controlled) is null;
  with procedure Adjust     (Object : in out Controlled) is null;
  with procedure Finalize   (Object : in out Controlled) is null;
Package Controlled_Mixin is
  
  Type Instance is new Ada.Finalization.Limited_Controlled with record
    Component : Controlled;
  end record;
  
  --...
End Controlled_Mixin;

> 
> Based on what I have read so far, I didn't see any discussion that would
> lead me to think this will be changed at least in the near future.  I
> wish there was a way it would be easy for vendors to do something like:
> 
> type Some_Type is tagged private;
> for Some_Type'Initialize use Initialize_Some_Type;
> for Some_Type'Adjust use Adjust_Some_Type;
> for Some_Type'Finalize use Finalize_Some_Type;
> 
> and then just have the compiler handle adding the needed structures
> to the type under the hood (like how GNAT uses Controlled to hold
> a linked list under the hood...but compiler managed).

That would be pretty nice.