Re: += in ada

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

18k11tm001@sneakemail.com (Russ) writes:

> Yes, and there is a huge difference between 100000.0 and 1000000.0
> too. There is a huge difference between X := Y * 2 and X := Y + 2.
> There is a huge difference between X <= Y and X >= Y. So what? I have
> no trouble distinguishing between them, and I have no trouble
> distinguishing between := and :+. They look as different as day and
> night to me.

I agree that X <= Y and X >= Y can be distinguished easily.
But 100000.0 and 1000000.0?  They look almost the same to me.
A good Ada programmer would write 100_000.0 and 1_000_000.0.
In C (etc), you can't do that.

I still don't get what you think is so important about these increment
operators.

It would certainly be convenient if there were a built-in way to
increment a variable without writing the variable name twice,
especially when the variable name is something complicated like
A[I].C.all.  Is that what you're getting at?

Or do you insist that "A[I].C.all :+ 1" or "A[I].C.all += 1" is somehow
much more readable than "Inc(A[I].C.all)"?  Or, in pseudo-COBOL,
"Add 1 to A[I].C.all"?

What about the fact that += in C can have side effects?  That is, you
can say "while (x += 7)...", using both the *result* of +=, and its
effect of addition.  I consider that bad.  Do you?

The best solution to this, in my opinion, would be to allow one to
write:

    procedure Inc(X: in out Root_Integer'Class);

This would require that the type Root_Integer (from which all integer
types are ultimately derived, in Ada) to be nameable, and it would
require the class of all such types to be nameable via 'Class.

Such a facility would be quite powerful and quite useful.
And of course Inc could easily be predefined.
And some folks might prefer it called by infix ":+" or some such
(not me).

What I don't get, though, is why you think such notations are so
*important*.  Yes, C has a nice notation +=.  Yes, many languages have
inherited that notation.  So what?  It's just plain silly to suggest
that this notation is responsible for those languages' popularity,
or that the lack of such notations leads inevitably to the demise of
Ada.

I do agree with you that it would be nice to have a notation for
incrementing a variable without naming that variable twice.
And I do agree with you that "procedure Inc" is not a good solution
(in current Ada) because it requires a separate Inc procedure for
every integer type.

- Bob