Re: Overloading operator "=" for anonymous access types?

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On 2019-01-15 22:00, Randy Brukardt wrote:
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
> news:q1k65j$1qqm$1@gioia.aioe.org...
> ...
>> [ The reference manual is shy to say anything about it. It claims that
>> universal_access is kind of class-wide, which would mean, if taken
>> seriously, that "=" overloads and must clash with the original "=".
> 
> This is what happens. However, such a clash would mean that you could never
> write a user-defined "=" for an anonymous access type. That would have been
> a good idea, but it would have to have been enforced with a Legality Rule to
> be sensible. Some thought that bad because of compatibility, so...
> 
>> Since it does not, universal_access is more like a parent type than
>> class-wide.]
> 
> ...there is a hack to have a preference for the user-defined one. That
> doesn't change the the fact that universal_access is class-wide, it just
> make it possible to write a user-defined operator.

Yes, you need hacks to handle inconsistencies and weaknesses.

>> P.S. And, wouldn't it be better to fix the type system, no?
> 
> This wart would be one of the things that would make "fixing the type
> system" so much harder. A proper solution (and the one we should have used
> in the first place) is to declare a "=" for every access type. I think we
> wanted to avoid that as anonymous access can be declared in places where
> declarations aren't allowed, so we came up with something worse. :-)

I think the problem is that all operations with access T as an argument 
should be primitive operations of T. That was the idea behind anonymous 
access types all the time. But some types are not so much types to have 
classes.

> It's the idea of anonymous access types that destroys the type system that
> you have in mind. Your system keeps the types and operations together, and
> that makes no sense for an anonymous type (what are the operations for an
> anonymous type, and where are they declared? Any answer is either magical or
> nonsense.)

Yes, there is a conflict between anonymous access type treated as a 
standalone type and as a parameter passing mode of the target type.

> One has to get rid of nonsense things before one could regularize the type
> system, especially upon the lines you have been suggesting for years. It's
> not really possible for Ada; you would end up with an Ada-like language.

We may be able to express this in the terms of a more general type 
system. If anonymous access would be a mere user-defined type with all 
its perks that would be OK.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de