Re: Proposal: Auto-allocation of Indefinite Objects

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On 01/08/2020 13:22, Stephen Davies wrote:
> On Friday, 31 July 2020 at 11:20:09 UTC+1, Dmitry A. Kazakov wrote:
>> On 31/07/2020 11:25, Stephen Davies wrote:
>>> On Friday, 3 April 2020 at 23:48:43 UTC+1, Stephen Davies wrote:
>>> Perhaps a better way to think of this is as a discriminated record without
>>> an explicit discriminant? In which case maybe a different syntax than "new"
>>> would be appropriate?
>> That is right, but it would be a much larger problem to resolve than
>> your original proposal.
>> First, Ada lacks necessary discriminants ...
>> Second, Ada's object initialization process has no means to determine
>> discriminants...
>> Third, there is still the problem that task components do not work...
>> All in one, the crude work-around has always been an access type...
> 
> Maybe I'm missing something but my thought was maybe there is no
> need for a named discriminant, e.g.
> type Node_Type (<>) is record
>     Item : Element_Type;
>     Prev : Node_Ptr_Type;
>     Next : Node_Ptr_Type;
> end record;
> The rules for such records would be the same as for discriminated ones,
> except that instead of usages needing to provide values for discriminants,
> they would need to provide values for indefinite components.

1. There is no discriminants for cases when Item is T'Class.

2. You cannot get discriminant from the value in the case of Rosen 
trick. Consider Item being a task with the access to the actual node as 
its discriminant:

    type Node_Type;
    task type Worker (Node : not null access Node_Type) is ...;
    type Mode_Type is record
       Item : Worker (Node_Type'Unchecked_Access);
       Prev : Node_Ptr_Type;
       Next : Node_Ptr_Type;
    end record;

You cannot initialize Item because you cannot construct Worker without 
having the node. And you cannot have the node without having Item 
initialized.

3. Copying is involved. There should be none, especially for limited 
types. Limited returns are broken per construction and nothing could 
ever fix them.

-------------------------
If the only problem were to deduce discriminants from a value. We could 
leave Node_Type as-is and simply fix aggregates:

    type T (L : Natural) is record
       S : String (1..L);
       I : Integer;
    end record;

Why not to make this legal?

    X : T := ("hello!", 123); -- L is deduced from S

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de