Re: Eiffel and Java + Ada dispatching

[jezequel@piccolo.is.s.u-tokyo.ac.jp (Jean-Marc Jezequel)]

In article <327F0D64.619A@iam.unibe.ch>, Robb Nebbe <nebbe@iam.unibe.ch> writes:
>On overloading:
>
>you need to keep in mind that a language is a tool. People become very frusterated
>with tools that interfere with doing work rather than help, unless they can
>rationalize this in terms of saftey or something. Overloading is the language
>getting out of your way so you can concentrate on what is really important.
>
>Think of it as separation of concerns. When you are writing software it is better
>to concentrate on finding meaningful names rather than "Did I already use that
>somewhere?" I have better things to do than manually resolving overloading.


Please let me use an example James Rogers sent me in a private mail:

type base_type is tagged record
   count : natural;
end record;

type derived_1 is new base_type with record
   Name : string(1..40);
end record;

type base_class_ptr is access all base_type'class;

Base_Obj : aliased base_type;
Derived_Obj : aliased derived_1;

Class_Ptr : base_class_ptr;

procedure print(Item : base_type);  -- (1)
procedure print(Item : derived_1);  -- (2)

-- Client side in Ada95

print(Base_Obj); -- static binding to (1)
print(base_type(Derived_Obj)); -- static binding to (1)
print(Derived_Obj);   -- static binding to (2)


-- Corresponding Client side in Eiffel (typical)

Base_Obj.print; --  binding to (1)
Derived_Obj.base_type_print; -- binding to (1)
Derived_Obj.print ;   --  binding to (2)


So usually finding a suitable name is not the problem when you lack overloading.
As for the preference on dotted or symetric syntax, someone already made the
point that it was no big deal.
And to be absolutely clear that this is not intented as an attack on Ada95, I claim
that I would be happy if I had to use Ada95 on a project (instead of say C++;-)

>You are correct in saying that there is no semantic difference between
>unique names and overloading. However, just because there is no semantic
>difference don't suppose that it doesn't play a critical role in how the language
>is defined. 

Yes, it does. For example by making things much more complicated;-)

>By the way, consider what Eiffel does. It determines which routine is to be called
>based on the name of the routine and the type of one of the parameters. The only
>difference with Ada is that Ada uses all the parameters. There is no semantic
>difference between determining statically or dynamically which method is invoked.

May be we have a different idea on the meaning of `semantics', but IMHO there is a 
difference. In one case it has to be done at compile time (and e.g. implemented using unique names as
you pointed out). In case of dynamic binding, it has (conceptualy) to be deferred until run-time,
and is basically implemented with a test on the object dynamic type (Ada tag?) to select
the right procedure.

In the head of the programmer, it makes a difference because she can assume that the most
"suitable" version of the procedure print will be called on x when she write x.print; 

Despite Ada95 being much more clear than C++ in this respect, in complex cases involving
both overloading and dynamic binding, it is still hardly possible to
explain in one short sentence (like above) the concept of what's going on.

My only point in this thread was that having both overloading (selecting the procedure at
compile time based on the static type of *all* the operands) and single distpatch (basically
selecting at runtime based on the dynamic type of one operand, plus minor Ada95 niceties) may
be confusing for some users. It's a matter of IMHO, so you won't need to agree with me.
BTW, I know it's not confusing for Ada95 experts (by definition;-)
But see the number of poeple who are still unsure whether Ada95 has multiple-dispatch a la CLOS,
or just an "augmented" single dispatch, e.g. the initiator of this thread.

Article Unavailable