Re: pragma Pure (Ada)

[Adam Beneschan <adam@irvine.com>]

On Oct 8, 3:54 pm, Yannick Duchêne (Hibou57)
<yannick_duch...@yahoo.fr> wrote:
> Le Sat, 08 Oct 2011 03:37:53 +0200, Adam Beneschan <a...@irvine.com> a  
> écrit:> So a special rule had to be added to make the language *prefer* the
> > "universal access" equality function over any other function.
>
> > Hope this helps,
>
> Yes Adam, that help, but raise another question: the choice of the  
> anonymous access type operator is surprising to me. Why was the choice of  
> the more specific operator rejected ?  I guess this may be because the  
> anonymous access type may not always be a valid parameter for the more  
> specific redefined operator of the named access type (ex. different  
> storage pool), but the choice of the least specific operator, is  
> counterintuitive,

Actually, I think the opposite is true.  Say you have a package that
defines a record type Rec1 which defines an element of a linked list,
and it has a Link field:

   Link : access Rec1;

Now, in another package P2, you have some reason for defining your own
access type that accesses Rec1.  Maybe it's declared as a private
type:

   type Employee is private;

but you decide to implement it as an access-to-Rec1, in the private
part:

   type Employee is access all Rec1;

If we followed the rule you say is "intuitive", then any time in the
body of P2, you wrote

   if A.Link = B.Link then ...

the Link fields would suddenly be treated as having type Employee
(because the "=" operator on Employee would be used), even though Link
wasn't declared as having type Employee and the Employee type wasn't
even visible at the point the Link was declared.  This, to me, is
counter-intuitive.  So I think you've gotten it backwards.

The example is somewhat contrived; it's hard for me to think of a good
real-life example.  In practice, "=" won't be redefined that often,
which means it really doesn't matter which one the compiler picks.
You're going to be comparing two addresses for equality, no matter
which one is picked.  But there have to be some rules to allow the
compiler to pick one.  And, as Niklas pointed out, if there are
multiple named access types visible that access the same designated
type, using the "more specific" operator would still produce ambiguous
errors, which is not desired.

                                  -- Adam