Re: Ada functions versus arrays (i.e. () vs [] )

[blakemor@software.org (Alex Blakemore)]

I previously posted the next two lines AB
> >C has some elegance but why should the programmer have to remember
> >when to use [] or () ?  

In article <5619@crdgw1.crd.ge.com> hammondr@sunroof.crd.ge.com (Richard A Hammond) writes:
> ...  I think the reason is to give the programmer a cue
> to what is going on.  Remember, the goal of C is to provide constructs
> which map in a straightforward way to machine code.

That is not Ada's goal (as most compilers remind us :-)
The question is what you mean by "what is going on".
The important thing for the caller is the type and content of whatever
name (args) returns, not how/when it is computed.  (That is important too,
but the responsibility for that lies with the code providing the service.)

> The C programmer is interested in the difference between an
> array reference and a function call.

So are Ada programmers, no one is keeping that information from you.
You are free to go look in the package spec any time to see what exactly 
you are referencing.  And if you dont like the way it is implemented,
you can change it IN EXACTLY ONE PLACE. The meaning of calling programs
is not changed if the switch between array/function implements the same
abstract function.  Only their efficiency changes.

(i.e. Ada allows you do it right, there are still ways to mess it up such as ...)

> In fact, the argument that "an array ref" is the same as a "function call"
> is true for mathematical functions but not Ada ones.  Ada functions can
> have side effects, which is a software engineering deficiency in Ada.

I agree that side effects are best avoided - they definitely mess up this
scheme.  I assume the language designers left them in for the 
very few times when they are justifiable (e.g. next_random_number).
Quite possibly a language design error forced on them by C programmers :-)

At least this syntactic overloading is consistent with other Ada features,
such as private types.  One of the things I love about Ada is being able
to encapsulate the representation of a type or object using a private type.
Again, this doesnt mean the user of the type shouldn't know how it is
implemented.  It means he can confidently change the representation
in one place and easily reason about how that change will affect
the rest of the program (if at all).

--
-------------------------------------------------------------------------
Alex Blakemore             blakemore@software.org          (703) 742-7125
Software Productivity Consortium   2214 Rock Hill Road Herndon, VA  22070
------------------------   Eschew Obfuscation !!! -----------------------