Re: Oberon and Wirthian languages

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

"Simon Clubley" <clubley@remove_me.eisner.decus.org-Earth.UFP> wrote in 
message news:ljekbl$bbt$1@dont-email.me...
> On 2014-04-24, Randy Brukardt <randy@rrsoftware.com> wrote:
>>> On 14-04-24 21:51 , Simon Clubley wrote:
>> ...
>>>> It will be interesting to see if Randy and company have any comments on
>>>> this syntax.
>>
>> Not really, other than that someone needs to come up with syntax that has
>> the right "feeling". None of the proposals I've seen have that yet, but 
>> keep
>> trying.
>>
>
> Ideas on what you think is wrong with the current suggestions will be
> useful.
>
> Do you have some general approach in mind which you would prefer ?

I prefer the partial aggregate approach; it comes up so often in practice 
and compilers have to bend over backwards to optimize the case. (The 
Janus/Ada compiler is stuffed with such aggregates that change a 
discriminant but little else of the content, I spent several weeks writing 
optimizations so that doesn't necessarily copy everything in a large record. 
But of course that has to be turned off for volatile and atomic objects.)

But the syntax proposed doesn't have the right "feel". The connotation of 
the syntax has to match fairly closely the semantics of a feature, 
especially when we're in nice-to-have territory as this is. (After all, 
temporaries work; they might be a bit ugly but that's hardly a reason for a 
language feature.)

This is a case where the keyword will make all of the difference. If we were 
using a new keyword, perhaps something like:

   A := (A replacing C => D, E => F);

would do the trick.

I don't find your Pascal-derived idea very appealing, because its so foreign 
to Ada. Something based on aggregates feels more in tune with the rest of 
the language.

To get assignment atomicity, probably extending the aspect syntax to 
statements would be best. (The Parallel proposals are thinking in that 
direction anyway.) Then something like:

   A := (A replacing C => D, E => F) with Atomic;

would mean to do an atomic update of A replacing the C and E components, 
leaving the rest untouched.

                                Randy.