Re: Issue with GNAT GPL 2009 and GtkAda

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

On Mon, 29 Jun 2009 16:59:40 -0500, Randy Brukardt wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:u7txi934iaog$.gw40yhq8811x.dlg@40tude.net...
>> On Fri, 26 Jun 2009 16:38:45 -0500, Randy Brukardt wrote:
> ...
>>> As far as the use of class-wide components, I think that would be easily
>>> fixed by just allowing them.
>>
>> That would make objects non-contiguous. It is not obvious to me how that
>> will work with streams and pools. I prefer a more transparent model when
>> all components of a constrained object are constrained.
> 
> Well, Ada has always allowed non-continguous objects. There is no problem 
> with streams: the stream attributes take care of any non-contiguous parts. 
> As for pools, multiple calls to Allocate are allowed; again there is no 
> requirement that the objects are contiguous. (That's been confirmed by 
> AI05-0107-1, but it has always been true for Ada 95; there are plenty of 
> AARM notes making that clear).

OK, but I still feel bad about it. (:-))

>>> That would reduce the need to use access types some more. (But it can never
>>> be completely eliminated; sometimes you really do need reference semantics,
>>> especially for returns.)
>>
>> No, this is the mental trap. If something requires by-reference semantics
>> that is not a return. Considering containers:
>>
>>   A (I) := X;
>>
>> It is a semantic mistake to treat A (I) as a function "returning"
>> something. This can only lead to introducing more and more strange
>> constructs like limited aggregates, return statements and other mess.
>>
>>   A (I) := X;
>>
>> must be treated as a syntax sugar for a procedure call
>>
>>   Put (A, I, X);
> 
> That works for full object assignment, but not in any sane way for in-place 
> component updating. And full object assignment really doesn't need any 
> special syntax (Replace_Element works just fine); the problem is when you 
> need to update a single element of a container which is itself an element. 

Ah, that is an interesting issue. Let us compare it on the example of
multi-dimensional arrays. Should A(I,J) should better be A(I)(J)?

I do not think that LHS indexing is "composable" in "C-way" without further
assumptions. It should not be taken for granted. In cases of genuine
reference semantics I would prefer a container of controlled access types
to T rather than a container of aliased T returned by reference. I want it
explicit like it is now:

   type Container is array (...) of access T;

What is missing is finalization of access T by Unchecked_Deallocation and
assignment T to access T by new T'(...).

BTW, the public view of such container could be array of T. For example:

   type Container is array (...) of T is private;  -- Not Ada!

private
   type Container is array (...) of access T;
       -- implementation per controlled references

> It doesn't make sense to try to think of these sorts of operations as a 
> single procedure.

Why not? In general case of container composition, I would indeed provide
the syntax:

   A (I, J, ...) := X;

implemented by a primitive operation

   Put (A, I, J, ..., X);

With introducing index types (tuples) it does not depend on dimension:

   Put (A, (I, J, ...), X);

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