Re: Pb with use of redefined "=" operator

[Matthew Heaney <matthew_heaney@acm.org>]

dewarr@my-dejanews.com writes:

> In article <m3iugv70ke.fsf@mheaney.ni.net>,
>   Matthew Heaney <matthew_heaney@acm.org> wrote:
> 
> > It is for this reason that I always implement (the full view of) ADTs as
> > tagged, even if the partial view is not itself tagged.
> 
> 
> I think that this is definitely a wrong approach. The fact of the matter is
> that when you get to complex record types, it is rather rare to use the
> equality operator meaning just component equality. It seems quite unnecessary
> to introduce the overhead resulting from gratuitous tagging just in case this
> (mis)use occurs.

So you don't like this implementation of a stack?

   type Stack_Type is private;

private
...
   type Stack_Type is
      tagged record
         Items : Item_Array;
         Top   : Natural := 0;
      end record;


The tagging here hardly seems gratuitous, as it's necessary to correct
what is arguably a flaw in the language!

> In practice I think that the problem is way overblown. Yes, it does cause
> some troubles, as we see from yet another thread started up on the subject,
> for those who don't know the language rules, but lots of things cause trouble
> if you don't know what you are doing!

I don't think this is an accurate comparison.

It is pure fantasy to think that every programmer is going to remember
the somewhat abstruse rules for what operators apply to a type when used
as a generic actual type.

The simplest approach is: 

o write your ADTs so that equality always composes

o when importing a type as a generic formal, use only the equality
operator passed in, and not aggregate comparison

This way the code always works, and no one has to think - which is the
entire point of abstraction!