Re: Legit Warnings or not

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:110nibt4tsn7q.162t6eli286tt.dlg@40tude.net...
> On Mon, 1 Aug 2011 17:12:23 -0500, Randy Brukardt wrote:
...
>>  > 4. Why a built-in implementation of array of S'Class (what you seemed 
>> to be
>>> arguing for) should be easier/more efficient/more compatible to Ada than 
>>> an
>>> implementation trough Ada.Container only publicly visible as an array?
>>
>> There is no new magic needed to allow S'Class as a component type -- only
>> the removal of a single legality rule (much like Ada 2005 eliminated the
>> library-level requirement on derived tagged types).
>
> That is because your compiler already implements this magic. Other
> compilers may have problems with that.

True enough, but that surely was true for removing the library-level 
requirement -- no compiler had that magic. My point was that such a change 
does not change the model of the language at all -- the only cost 
(admittedly, not trivial) would be for implementations.

> And for a programmer the problem is to have control over the constraints
> (when the tag can be changed and when not) and over copying (when dynamic
> components get copied, when shared). You will need a lot of new keywords
> and syntax constructs to specify all possible and needed combinations of
> these, plus terrible rules about how these constraints are propagated upon
> composition and inheritance. What happens in generics etc.

That's taking a simple change and making it far more complex. I'm suggesting 
changing 3.6(10) [only] to allow S'Class. Nothing further, and this isn't 
making any attempt to allow more of anything else.

Indeed, allowing this would have to be tied to eliminating the bogus 
possibility of having partially constrained S'Class subtypes. (The vast 
majority of compilers don't support this possibility, even though the 
language insists on it). Thus there are no constraints to "have control 
over". Either you are allowing changing the object to anything in the class, 
or you are not allowing it to be changed at all. No middle ground there.

And there is no "control over copying". These are normal "parts" of the 
object, and they're always copied. If you don't want copying, then you need 
to use some sort of reference (cursor or access type). (Of course, an 
implementation can always do an "as-if" implementation, but the model is 
always deep copying.)

There is no need or value to trying to go beyond that. "Shallow copying" is 
nasty; pretty much the only value is for performance reasons and it is best 
to leave those to the compiler. (Premature optimization and all of that.)

> To me it is just an overkill. Ada already suffers a plethora of 
> unorganized
> special cases of types instead of a clean and *small* type system.

This would *eliminate* some of the special cases (allowing more types 
unfettered as components and objects). Ada is at the point in its life where 
only incremental changes can happen -- so redoing the Ada type system isn't 
happening.

                                         Randy.