Re: Ideas for Ada 200X

[tmoran@acm.org]

>>> Add(A, C);
>> And the person reading this code couldn't be sure what was going on in
>> "Add" without looking at the procedure itself (or perhaps its
>> declaration). How would the reader know if the sum will end up in the
>> first or second argument?
  "Come the revolution, comrade, we'll all do it my way, with the
assignee on the left." ;)
  If the reader is in doubt, he will indeed have to look at the spec of
procedure Add to know what it is supposed to do.  If Add is used in only a
very few places, then a good Ada programmer would go to the trouble of
writing it out the long way, with named parameter association.  If
Add is used a lot, it's more reasonable to lessen verbosity and
instead require the reader to look up the definition of procedure Add,
and use positional parameters.
  Of course it may be that Add actually sets its first parameter to all
zeros or something, but that could also happen if a compiler translated
"A += B;" to "Add(A,B);"

> That's why this Ada programmer (good or bad, I won't say!)
> would write it as
>
>     A := B;
>     Add (Into => A, C);
  At which point his compiler would gently point out that once
(from left to right) you've started using named parameters you
can't go back to positional, so he needs to write
      Add (Into => A, Increment => C);
or
      Add (A, Increment => C);

Of course it's also true that once you've changed
A := B+C+D;
to some series of "+=" or "Add"s, you've made things obscure and hard
to read, in favor of the speedup you needed.  Anytime he lessens
readability, the good Ada programmer will put in comments explaining
what he is doing and why he is doing it this non-straightforward way.