Re: Ada Annoyances

[Maciej Sobczak <see.my.homepage@gmail.com>]

> C++ needs this model

In other words, what it offers is complete. Sounds fair.

> In Ada, where redispatching requires explicit work, the vast 
> majority of constructors will never make a dispatching call so there is very 
> little risk.

The vast majority? Where does this statistics come from?
I expect programmers to delegate initialization of the base parts to the initialization procedure that was already written for the base part, like here:

      procedure Initialize (Obj : in out Derived) is
      begin
         -- initialize Base part:
         Initialize (Base (Obj));
         
         -- initialize Derived part:
         -- ...
      end Initialize;

I'm not sure whether this is majority or minority, but the idiom seems to be intuitive. The problem is - even though the view conversion is explicit here, the dispatching call in the Base version of Initialize is not and it is there, where the potentially unsafe action can occur. These two places can be in separate files, written by different programmers. If you decouple explicit from unsafe, this is no longer in the Ada spirit.

The complete example (analogous to the C++ example I have written in the other post) is:

with Ada.Text_IO;
with Ada.Finalization;

procedure Test is
   
   package P is
      type Base is new Ada.Finalization.Limited_Controlled with null record;
      
      procedure Initialize (Obj : in out Base);
      procedure VFoo (Obj : in Base);
      
      type Derived is new Base with null record;
      
      procedure Initialize (Obj : in out Derived);
      procedure VFoo (Obj : in Derived);
      
      procedure Use_Object (Obj : in Base'Class);
   end P;
   
   package body P is
      procedure Initialize (Obj : in out Base) is
      begin
         Ada.Text_IO.Put_Line ("   call from Base's Initialize");
         Use_Object (Obj);
      end Initialize;
      
      procedure VFoo (Obj : in Base) is
      begin
         Ada.Text_IO.Put_Line ("      Hello from Base");
      end VFoo;
      
      procedure Initialize (Obj : in out Derived) is
      begin
         -- initialize Base part:
         Initialize (Base (Obj));
         
         Ada.Text_IO.Put_Line ("   call from Derived's Initialize");
         Use_Object (Obj);
      end Initialize;
      
      procedure VFoo (Obj : in Derived) is
      begin
         Ada.Text_IO.Put_Line ("      Hello from Derived");
      end VFoo;
      
      procedure Use_Object (Obj : in Base'Class)  is
      begin
         VFoo (Obj);
      end Use_Object;
   end P;
   
begin
   Ada.Text_IO.Put_Line ("test with Base");
   declare
      B : P.Base;
   begin
      null;
   end;
   
   Ada.Text_IO.Put_Line ("test with Derived");
   declare
      D : P.Derived;
   begin
      null;
   end;
end Test;

When executed, we get:

test with Base
   call from Base's Initialize
      Hello from Base
test with Derived
   call from Base's Initialize
      Hello from Derived   <<<<<<< here are dragons!
   call from Derived's Initialize
      Hello from Derived


> In any case, this problem is irrelevant.

So guess how did I learn about it...

> The net takeaway is that a truly type-safe language maybe could be 
> constructed,

Yes. C++ got that part right.

-- 
Maciej Sobczak * http://www.inspirel.com