Re: Hiding the value of Constants

[Adam Beneschan <adam@irvine.com>]

On Jul 7, 3:41 am, Hibou57 (Yannick Duchêne)
<yannick_duch...@yahoo.fr> wrote:

> As some one are talking about Funny_Types, here is a funny thing
> (thinking about it when I saw this solution) : Ada defines enumeration
> contants as parameterless functions (just like you propose for these
> constants).
>
> RM 2005 3.5.1 says:
>
> > 6 {enumeration literal} Each enumeration_literal_specification is the
> > explicit declaration of the corresponding enumeration literal: it
> > declares a parameterless function, whose defining name is the
> > defining_identifier or defining_character_literal, and whose result
> > type is the enumeration type.
>
> But this is with some restrictions (ex. one may not get the adress of
> such a function)
>
> This has some conscequences on the name resolution of an enumeration
> literal reference vs of a constant reference. Sometimes I wish both
> will be one day handled the same (enumeration literals and constants

I believe the reason enumeration literals are actually functions is so
that you can use the same enumeration literal in more than one
enumeration type and not have to worry about name conflicts.  The
overloading rules will allow the compiler to figure out which one is
meant.  There are additional bonuses, such as being able to use an
enumeration literal as the actual for a generic instantiation that
expects a function.  How useful that is in practice, I don't know.

I'm not sure why you would want enumeration literals to be treated
like constants, though.  I don't know of any advantage to making them
officially "constants"; that is, I can't think of any language rule
off the top of my head where a constant would be allowed but a static
function such as an enumeration literal couldn't.  In effect, I
believe you can use them anywhere a constant could be used, and in
some places where constants can't.  If you mean that you'd like
constants to be treated like static functions, so that you can
overload them:

    Max : constant Integer := 15;
    Max : constant Float := 15.0;

that's an intriguing idea.  Not intriguing enough for me to have to
make all the necessary changes to our compiler, but intriguing
nonetheless....

                                -- Adam