Re: Task components, the rationale

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

On Jul 13, 8:52 pm, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:

> Now, if My_Worker started before completion of Initialize then this body
>
>    task body Worker is
>    begin
>        Self.Foo; -- Boom!
>
> could call Foo of T or any of its derived type *before* Initialize, i.e.
> before the object's construction is done! That would be a much worse
> problem.

I don't even think you need to introduce tasks to show the problem -
what if the component is of another controlled type? Then you have two
nested calls to distinct Initialize operations - the first one for the
component (where you have the discriminant access value to play with)
and the second one for the whole, which is too late:

with Ada.Finalization;
with Ada.Text_IO;

procedure Test is

   type Outer;

   type Inner (Shell : access Outer) is
     new Ada.Finalization.Limited_Controlled with null record;

   overriding procedure Initialize (Self : in out Inner);

   type Outer is new Ada.Finalization.Limited_Controlled with record
      I : Inner (Outer'Access);
      Some_Value : Integer;
   end record;

   overriding procedure Initialize (Self : in out Outer);

   procedure Initialize (Self : in out Inner) is
   begin
      Ada.Text_IO.Put_Line
        ("initializing inner, Self.Shell.Some_Value =" &
           Integer'Image (Self.Shell.all.Some_Value));
   end Initialize;

   procedure Initialize (Self : in out Outer) is
   begin
      Self.Some_Value := 123;
      Ada.Text_IO.Put_Line
        ("initialized outer, Some_Value =" &
           Integer'Image (Self.Some_Value));
   end Initialize;

   X : Outer;

begin
   null;
end Test;

$ gnatmake test
...
$ ./test
initializing inner, Self.Shell.Some_Value = 0
initialized outer, Some_Value = 123
$

We are messing with the state that does not yet exist. Oops.

> There is no simple solution for this.

You have to just, you know, simply, introduce constructors to the
language. This is my pet feature for Ada 2020. :-)

> To start with tasks must be
> inheritable from and their bodies must be primitive or class-wide
> operations, because aggregation (composition) + Rosen's trick is
> necessarily broken.

It's not about tasks, it's about access discriminants to outer records
- they introduce circular references (outer has inner, inner knows
outer) and as such are evil.

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