Re: Ada 2005 puzzle

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

On Fri, 20 Jul 2012 19:04:05 -0500, Randy Brukardt wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:1agfifqlayl3y.1bp09z5i37ewk$.dlg@40tude.net...
>> On Thu, 19 Jul 2012 21:22:27 -0500, Randy Brukardt wrote:
> ...
>>> The ARG isn't going to do anything unless real users (like yourself) report
>>> reasonable examples that don't appear to be possible with the current rules.
>>> Generally, we're not interested in *solutions* from the public (we're happy
>>> to figure out the best solution for the language as a whole), but we are
>>> interested in *problems*.
>>
>> The problem is just same it was when ARG invented limited aggregates and
>> function returns.
> 
> Sorry, I meant *specific* examples of useful things that you cannot find a 
> legal way to write.

The example I posted illustrates the problem as found in original code,
which is too large and proprietary anyway. 

> No one is likely to be that interested in philosophical concerns.

Huh, what were *specific* examples caused ARG to accept limited aggregates
and functions?

>>> So far as (most) of the ARG is aware, there is no problem with this feature,
>>> and in the absence of reports of real problems I doubt that anything will
>>> change.
>>
>> You could simply say that you agree/disagree with the principle.
> 
> I actually see little wrong with the Ada model.

Rightness here would mean conformance to the principle that a limited
aggregate were *always* possible to write when the nearest non-abstract
ancestor had visible constructing function, or something else?

> And the "problem" 
> that you had was artifically introduced because some implementers thought 
> implementing that would be hard.

I don't understand that, I am not a language lawyer. You are. Is my example
legal and GNAT wrong? In case it is illegal, then how do I change the
aggregate to make it legal.

> So you need to work harder to convince me. And I'm not going to be able to 
> do a very good job of convincing anyone else.

Adam, another language lawyer, wrote that he was aware of the cases when
aggregates were impossible to write. That that point all alarm bells should
start ringing, no?

> As I said, we need realistic 
> examples of problems that cannot be solved with the current rules.

You would have plenty if you tried to make Claw objects limited. Working
around such aggregates is one of the worst Ada issues I have. On top of
that consider the case when the function is to return a class-wide object
constructed using such an aggregate.

> (And that isn't just addressed to you; it's really addressed to every user 
> of Ada. Too many people work around problems without pointing out their 
> language difficulties to us; we're never going to be able to fix language 
> problems we don't know about!)

People actually using Ada have deadlines to meet. The best we could do is
to record the issue and start working it around. If anybody had time to
report a problem, he would be asked for an AI. Should he spent even more
time and forged some AI, that would be discarded on whatever grounds. 

Don't get me wrong, I don't say this is wrong. Wrong is to expect us, Ada
programmers, doing ARG's job. We can only point out that something is
missing/wrong/difficult. The rest is up to ARG. Especially when it is about
such fundamental issues as construction of limited objects.

>>>> Why not to fix that too? Objects with the no-copies semantics are
>>>> everywhere. Larger/complex the object become, less likely anybody would
>>>> copy it. Clearly, Ada as a language for *large* projects shall support
>>>> this.
>>>
>>> It can't be fixed; you almost always need copying in some circumstances.
>>
>> No, you never need copying except for scalar objects and marshaling.
> 
> All objects need marshalling, and that's one of the obvious problems.

Nope. There is no way you would marshal GUI button, network socket, task,
linked data structure etc.

>>> And if you expect me to take your problems to the ARG, let me say that they
>>> will have a lot more weight if they come from real Ada users and not just me
>>> (or Adam, or Bob, all of whom are "tainted" as implementors).
>>
>> You mean ARG is unaware that constructing functions cannot be written in
>> the cases like presented? Or that they would not believe you or Bob telling
>> so?
> 
> Definitely unaware -- I've never previously seen a case that couldn't be 
> written with a bit of effort.

Well, well, you knew that it did not work, but hoped that laymen could
never be able to discover that? (:-))

> Anyway, spend a few minutes and send an example like your original one to 
> Ada-Comment, and it will get discussed properly. Otherwise, don't gripe 
> about it, because it surely isn't going to change.

This is what I was afraid of, because the problem is not fixing this
particular example but to ensure that no other examples like this existed.

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