Re: Possible Ada deficiency?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Jeffrey Carter <spam@spam.com> writes:

> Robert A Duff wrote:
> 
> > Jeffrey Carter <spam@spam.com> writes:
> >
> >>All such types would, of course, be passed by reference.
> > Well, that would require changing the current rules,
> > which require pass-by-copy for a private type if the
> > full type is elementary.  (I don't much like the existing rules
> > in this area, but I'm not sure the change suggested here would
> > be an improvement.  It would be seriously incompatible, for
> > one thing.)
> 
> It's not going to happen in Ada anyway, ...

True.  I guess I shouldn't use upward compatibility in an argument about
pie-in-the-sky language design.

>...and if you designed a language
> to work this way, you wouldn't have such rules in the 1st place.

What rule would you prefer (in a from-scratch language design)?

The main thing I dislike about the Ada rule is that it is possible to
write code by accident that behaves differently because one compiler
chooses pass-by-copy and another one pass-by-reference.  And it's not
clear whose responsibility it is to worry about this kind of bug: should
procedures be written so that they work even in the presence of aliasing
among actual parameters?  Or should callers avoid that aliasing?  And
what can the caller know about data modified in a procedure that raised
an exception in the middle of processing?

I also think it's kludgy to treat (say) integers differently from
strings.  I understand the efficiency reason for this, but I still don't
like it.

I can think of several solutions, but I'm not sure which is best.
One idea is to define all parameter passing to be nominally by copy,
but add some features that allow the compiler to know enough about
global variables and whatnot, so that it can use by-reference in most
cases, having proved it doesn't make any difference.  That wouldn't work
in Ada because the compiler doesn't have enough information to do the
proof, in most cases.

- Bob