Re: Constant as anonymous functions : the outer space beast is back

["Randy Brukardt" <randy@rrsoftware.com>]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2272 bytes --]

"Hibou57 (Yannick Duch�ne)" <yannick_duchene@yahoo.fr> wrote in message 
news:454c900f-85ed-4a40-ad13-a5b432261b99@c29g2000yqd.googlegroups.com...
>On 30 jan, 09:45, AdaMagica <christoph.gr...@eurocopter.com> wrote:
>> And even if you make Count a function (overloadable), this example
>> code is still illegal in Ada as is - and that's a good thing.
>>
>> package P is
>> function Count return Float;
>> end P;
>
>Yes, because the Count loop variant still hide the one from P.

Right, but that wouldn't be true in your suggested semantics, as the Count 
object would be overloadable. Even if you restricted that only to constants 
(of which Count is one).

It's clear that you haven't thought this through very well. Adam notes that 
you could just change the behavior of constants declared with "constant", 
but that makes no sense -- a renames of a constant object does not include 
the keyword constant. So such a "simple" rule wouldn't work.

Moreover, it doesn't make sense to treat constants and variables 
differently. The only sane choice is to change the behavior of *all* 
objects -- there is nothing that special about constants. Treating constants 
and variables differently would introduce a major maintenance hazard. The 
current principle (and one that ever programmer would expect) is that 
changing a declaration from constant to variable (or the reverse) only 
changes whether or not it can be written. Otherwise it ought to behave 
identically. Making the visibility rules wildly different for constants and 
variables would not have that effect (it's quite likely changing a constant 
to a variable would make some if it's uses illegal using your rule).

And it is bizarre to say that you are trying to increase consistency and 
then try to treat things syntactically declared one way from equivalent 
things declared in another way. How that could *increase* consistency is 
beyond my comprehension.

I had seriously proposed making objects overloadable declarations for use 
clause purposes only (mainly to decrease the maintenance hazard inherent in 
use clauses - which is really what you are complaining about), but that idea 
didn't get any traction. So nothing is going to change in this area.

                                 Randy.