Re: HELP: renames and enum values

["Samuel T. Harris" <samuel_t_harris@Raytheon.com>]

Ted Dennison wrote:
> 
> In article <38F5D6F9.5B8892F2@bton.ac.uk>,
>   John English <je@bton.ac.uk> wrote:
> > Dale Stanbrough wrote:
> > > All i was attempting to say is that
> > >
> > >    type blah renames bleh;
> > >
> > > could be predicted to have the same semantics as a subtype
> > > declaration (this would be the "other way" of performing
> > > subtyping).
> > >
> > > I know what beginners think of, because I had 8 years of
> > > teaching beginners. This is something that some of them
> > > thought of (but not many because most of them were introduced
> > > to subtypes long before renames!).
> >
> > What's even less obvious is the way to rename enumeration literals:
> >
> >  function Enum_Literal return Enum_Type renames Other_Enum_Literal;
> >
> > Now, that *really* confuses them, and none of them would ever be
> > able to guess it without being told!
> 
> What's wrong with:
>    Enum_Literal : constant Enum_Type := Other_Enum_Literal;
> 

package a is
  type x is (one, two, three);
  type y is (one, two, three);
end a;

with a;
package b is
  function one return a.x renames a.one;
  function two return a.x renames a.two;
  function three return a.x renames a.three;

  function one return a.y renames a.one;
  function two return a.y renames a.two;
  function three return a.y renames a.three;
end b;

with a;
package c is
  one : constant a.x := a.one;
  two : constant a.x := a.two;
  three : constant a.x := a.three;

  one : constant a.y := a.one;      -- compilation error
  two : constant a.y := a.two;      -- compilation error
  three : constant a.y := a.three;  -- compilation error
  -- these are co-resident homographs.
end c;

As I alluded to in a previous post, enumeration literals
are semantically defined as parameter-less functions. This
allows overloading them in different enumeration type
definitions. This also them multiple renames because the
correct renaming is a parameter-less function renames
declaration. Constants cannot be overloaded!

However, constants usually fill the bill in my actual
experience since overloaded enumeration literals simply
don't come up often in those rare cases where I need
to redefine the things. I say rare cases because there
are many other ways to get the adequate results that I
simply don't need to rename enumeration literals anymore.

-- 
Samuel T. Harris, Principal Engineer
Raytheon, Aerospace Engineering Services
"If you can make it, We can fake it!"