Re: += in ada

["Robert I. Eachus" <rieachus@comcast.net>]

> So, Robert and/or "Bob", would it be acceptable to the Guardians Of Ada's
> Purity if the semantics of a new "idem" feature were to specify that:
>    x := f(idem);
> could leave an arbitrary value in x in the event of a Constraint_Error being
> raised; thus always permitting an update-in-place implementation?

Robert would say no, Bob would say yes.  The ARG would spend a couple of 
hours discussing it and not change the current situation. ;-)  In other 
words, right now IF you need to you can write things so that x won't get 
corrupted.  Also you will normally get the fastest possible code 
generated.  It is only when those two principles collide that there is 
an issue.  Robert was happier with the Ada 83 rules.  Bob prefers the 
Ada 95 rules.  But in 90+ percent of the cases where Constraint_Error 
can occur, there are no practical differences between the rules.

If you are really concerned with insuring that the value of x doesn't 
get assigned a value even temporarily out of range, the new rules are 
more difficult to understand and follow.  Of course Bob would say that 
if you want good code, the Ada 95 rules are easier to work with.  The 
funny thing about all this is that in the debates about 11.6 over the 
years, people named Robert or Bob have been very active and vocal in 
expressing all possible points of view, mostly Bob Duff, Robert Dewar, 
and myself.  Bob Duff and I come the closest to being the Robert and Bob 
of the dialog, and Robert Dewar can certainly pinch hit for either one 
of us.

But that gets back to something that is hard to explain to people who 
haven't sat in on an ARG meeting.  It is a very strenous intellectual 
exercise, but we are all concerned with insuring that all possible 
issues are examined before the ARG makes a decision.  If you look at the 
history of some issues, we would meet vote 10-0 for some position and 
delegate someone to write the decision up.  The draft AI would then get 
voted down say 8-3, a new position agreed to, and the process repeated. 
  I'd have to check what the record on a single AI was, but Ada 83 
AI-315 was about this issue and was never completely resolved.  A lot of 
the new language in Ada 95 is supposed to resolve it, and I have yet to 
see a serious complaint from outside the ARG.  But it is an extremely 
difficult issue.  Let me give you the canonical problem, and see if you 
want to take a shot at it:

with Text_IO; use Text_IO;
with Integer_Text_IO; use Integer_Text_IO;
procedure Issue is
   X,Y,Z: Integer := 0;
begin
   Get(X); Get(Y);
   if X * Y > Integer'Last
   then
     Put_Line("Overflow!");
   else
     Z := X * Y;
     Put_Line("Okay");
   end if;
exception when Constraint_Error =>
   Put("Exception Raised. Z = ");
   Put(Z);
   New_Line;
end Issue;

What is the correct behavior for this program, if (mathematically) X 
times Y is greater than Integer'Last?  In Ada 83, in theory you could 
have a compiler that legally printed Okay, Overflow, or Exception 
Raised.  In Ada 95 we think we have ruled out Okay, but doing so is 
tough.  Of course the argument we are having here is about the value of 
Z in the exception handler.  That is a much easier issue than whether 
you get Overflow or Exception Raised.  (If it matters to you, consider 
it implementation dependent, and test the exact code you care about.)

-- 
                                                     Robert I. Eachus

"Quality is the Buddha. Quality is scientific reality. Quality is the 
goal of Art. It remains to work these concepts into a practical, 
down-to-earth context, and for this there is nothing more practical or 
down-to-earth than what I have been talking about all along...the repair 
of an old motorcycle."  -- from Zen and the Art of Motorcycle 
Maintenance by Robert Pirsig