Re: Enum'Image

["Frank J. Lhota" <NOSPAM.lhota.adarose@verizon.net>]

"Jacob Sparre Andersen" <sparre@nbi.dk> wrote in message
news:plhdt05wkw.fsf_-_@sparre.crs4.it...
> Frank J. Lhota wrote:
>
> > As an alternative, how about the ability to write your own Image
> > function?
>
> Definitely usable, but I would worry about:
>
>  1) if my implementation was as efficient as the compiler supplied one

Possibly not, but presumably you would not write your own Image function
unless you desired something different from the compiler-supplied Image
funciton.

>  2) 'Image and 'Value being each other's inverse

This is similar to the situation with user-defined "+" and "-" operators;
you would also want them to be inverses, in that most people would expect
that

    ( A + B ) - B = A

There is no way, however, for the compiler to force user-defined "+" and "-"
to be inverses of each other, so that responsibility falls to the
programmer.

The same could be said of user-defined Image and Value functions. Yes, they
should be inverses, but that is left up to the programmer.

> > If I had the task of inventing Ada over again, I would make cut a
> > lot of the attribute functions (such as 'Max, 'Image, 'Value, etc.)
> > and replace them with inherited subprograms that the programmer
> > would be free to override.
>
> I have had similar thoughts occasionally, but I am afraid there are
> some sensible reasons that it isn't already like that?

Enumeration literals can be overloaded, so I have heard the argument that
attributes are needed to resolve overloading. For example, if we have the
types

    type Name_Of_Nutrient is ( Vitamin_A, Vitamin_B, ... Calcium, Iron,
... );
    type Name_Of_Appliance is ( Blender, Microwave, Iron, ... );

then if we have the function call

    Image( Iron )

is it referring to the Name_Of_Nutirent Iron or the Name_Of_Appliance Iron?
This problem goes away if the Image function is an attribute, for then we
would write

    Name_Of_Nutrient'Image( Iron )

making it clear what the type of Iron we are taking about.

This is one way to resolve the ambiguity. Another way would be to use
qualified expressions. If Image was overloaded for these two enumeration
types, we could also clarify this function call by writing:

    Image ( Name_Of_Nutrient'( Iron ) )

> Jacob
> -- 
> "Any newsgroup where software developers hang out is
>  an Emacs newsgroup."