Re: ada paper critic

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

Hyman Rosen <hyrosen@mail.com> writes:

> Robert A Duff wrote:
>  > plan old variable names use the same
>  > notation as parameterless calls.
> 
> Don't forget that enumeration literals are considered
> parameterless functions. It's this syntax which allows
> different enumerations to share the same literals, yet
> have them be disambiguated by overloading in context.
> 
> A very elegeant bit of hackery!

Nonsense.  (Sorry. ;-))  The reasoning, apparently, was:

    1. We only want to overload subprograms.
    
    2. But we also want to overload enumeration literals.
    
    3. Therefore enumeration literals must be subprograms.

But the idea that enumeration literals are subprograms is patently
nonsensical.  It confuses people trying to learn the language.
It complicates compilers.  It provides no practical benefit
(i.e. no gain in expressive power).  It causes complication
in the RM (if these things are subprograms, then when exactly
are their bodies elaborated?  Can calling them raise Program_Error?)

The proper line of reasoning should have been 1, then 2, then
"3. Therefore we must have been wrong about 1."  Just define
enumeration literals to be overloadable.  And if enum lits can
be overloaded, why can't (for example) constants (which are more
like enum lits than enum lits are like functions)?

Sorry, "elegeant" is not the term I would use to describe this bit of
hackery.

Numeric literals are also overloaded, in a sense, although the RM
doesn't describe it that way.  (For subtle reasons involving named
numbers (another kludge), it's described in terms of implicit
conversion.)

Notations like aggregate notation are also overloaded.
No attempt is made to call aggregates functions (although
that makes some sense, at least for record aggregates).

- Bob