Re: Imitation is the sincerest form of flattery

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

On Thu, 27 Mar 2003 19:45:42 GMT, "Frank J. Lhota"
<NOSPAM.lhota.adarose@verizon.net> wrote:

>"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>news:b5qcnq$2bshmf$1@ID-77047.news.dfncis.de...
>> Frank J. Lhota wrote:
>>
>> > I wish that we had the following functions defined in the Standard
>> > package:
>> >
>> >     function Pred( X : Integer ) return Integer;
>> >     function Max( X, Y : Integer ) return Integer;
>> >     -- etc.
>> >
>> > This would allow the programmer to re-define any of these attributes for
>> > types derived from Integer (or other predefined types).
>>
>> True, but it is a very long way to go. For example, to have 'Max
>> dispatching, you would immediately need true multiple dispatch - it has
>two
>> parameters!
>
>AFAIK (and my testing seems to confirm this) if we have the function
>
>     function Max( X, Y : An_Integer_Type ) return An_Integer_Type;
>
>defined in the same package as An_Integer_Type, and if we derive a type
>New_Integer from An_Integer_Type, i.e.
>
>    type New_Integer is new An_Integer_Type;
>
>then New_Integer inherits Max from An_Integer_Type, i.e. there is an
>implicit function
>
>     function Max( X, Y : New_Integer ) return New_Integer;
>
>that the programmer can either call or replace with his own version.

This is absolutely another story. type A is new B, "clones" types. The
result is a new type which is same as B. From this point of view Max
is not inherited by New_Integer. Consider:

X : Integer;
Y : New_Integer;

Max (X, Y); -- Illegal!

Should Max be inherited Max (X, Y) would be legal.

BTW it is pitty that type cloning is not allowed for tagged types. IMO
this restriction should be removed.

>Multiple dispatching would only be an issue if we wanted to generate a
>version of Max that compares and / or returns different integer types. By
>the very nature of the Max function, we are unlikely to even want to do
>that.

My point is *IF*:

1. Inheritance has to be supported for all types in the sense that
Integer'Class might refer to descendants of Integer

2. The attributes has to be declared as primitive operations

Then you have to support MD for all attributes with several arguments.

So 'Max would be declared as:

   function 'Max (Left, Right : Integer) return Integer'Class;


There is no other choice. The present situation when tags of both
arguments has to be same is unsatisfactory. It is not so bad now,
because the tagged types are too heavy (passed by reference, have
embedded tag) to use them for representation of numeric things. There
binary operations are very common. Should you make OO available there,
this will become a problem:

   function 'Max (Left : Integer; Right : Integer'Class)
      return Integer'Class;

+ manual dispatch on Right is awful!

>This is not to dismiss the utility of multiple dispatching, but
>unfortunately most OOPL's avoid it because of efficiency concerns.

There are many problems with MD, but I do not think that efficiency is
a big issue. It will probably cost one indirection more.

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de