Re: Ada design bug or GNAT bug?

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

"Shark8" <onewingedshark@gmail.com> wrote in message 
news:4228c0ea-837d-42a0-b2a8-a98d8d30f820@googlegroups.com...
On Thursday, July 2, 2015 at 6:04:50 PM UTC-6, Randy Brukardt wrote:
>>
>> The reason Ada has anonymous access parameters was a desire (for Ada 9x)
>> that code from existing OOP languages like C++ could be directly 
>> converted
>> to Ada without having to think at all (thinking being necessary to get 
>> rid
>> of access types).
>
>Do you think, in hindsight that (anonymous access parameters) was a 
>mistake?

Surely. They were introduced mainly to solve two problems: the missing "in 
out" parameters for functions (and that they solved so imperfectly that Ada 
2012 allows "in out" parameters for functions), and to allow dispatching on 
access types (something I'm dubious was necessary in the first place - 
dispatching on .all works in virtually all cases that I've seen). Plus they 
have weird dynamic accessibility semantics, which provides a tripping hazard 
(as Bob Duff would call it) -- an exception but only in unusual cases -- and 
a performance drain. "in out" has essentially the same semantics put without 
the hazard or performance issue.

...
>I think I remember getting an error-message in GNAT awhile back
>about return and reference semantics... wasn't that something that Ada95
>had but was later forbidden in Ada 2005?

Because it was near-nonsense; you had to return a global variable -- but you 
should be avoiding global variables as much as possible, not requiring them. 
They had a few uses, but not enough to preserve.

> -- Also, do you think it would have been better to have extended-return
> signal to the compiler a desire for a build-in-place return-object?

Probably not, build-in-place semantics isn't practical for all non-limited 
types (think normal assignment, can't build-in-place because if an exception 
occurs the original value has to be intact).

> Also, I seem to recall your dislike of INTERFACEs -- in hindsight, what
> would you have done differently if you needed the mechanism of
> "Type T has functions X, Y, and X" applied to a group of types?
> Generics, or some variations thereof?

I wouldn't need such a mechanism. :-) I'm dubious of the value of that in 
the first place -- it's not zero, but it's close enough that it isn't worth 
hairing up a language or implementation to get it.

>>> with P1; use P1;
>>> package P2 is
>>>   type T3 is new T1 with private;
>> private
>>>   type T3 is new T2 with null record; -- Legal!
>>
>>This is only legal because of a hack, which I was very much against
>>introducing. If you have an extension component, this is illegal:
>>
>>    type T4 is new T2 with record C : Character := '1'; end record; --  
>> Illegal!!!

>Why is this hack required?/How was it justified? How would you address the 
>problem w/o resorting to this hack?

The thread that Dmitry and I have been having answers this question, and I 
don't want to spend time to repeat it.

>Other than those specifics, I'm quite interested to know what you regard to 
>be mistakes in Ada's design.

Someday I'm going to write a paper/blog post on that. But not today. I'd 
like to accomplish some work at some point in the month of July. :-)

                        Randy.