Re: Ada Interfaces and the Liskov Substitution Principle

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

On Sat, 02 Jun 2007 09:49:38 -0700, Maciej Sobczak wrote:

> On 2 Cze, 10:19, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
> 
>>> The difference is that (in Ada terms) replacement
>>> allows you to change the tag. Assignment cannot do this.
>>
>> Neither can.
> 
> Yes, replacement can change the tag. It's the tag of referred object
> that can change. An access variable can point to Circle and then to
> Triangle.

No, this is illegal. At least in Ada,: access Circle and access Triangle
are different types. They cannot be assigned to each other.

> I can also replace a wheel in my car but it's not assignment of
> wheels.

If you want to bring the issue of identity (the wheel) then that's again
subject shifting.

>>>> Ah, wouldn't replacement double dispatching?
>>
>>> No, it wouldn't and that's the second difference. Replacement just
>>> gets rid of the current value before the new value is refered to,
>>> which means that from the dispatching point of view this operation is
>>> simply linear on right-hand-side - it's a pure single dispatch.
>>
>> No, this does not work. Apart from being semantically wrong in general
>> case, it is technically wrong.
> 
> Why is it semantically wrong?

Because variables of T'Class can be assigned with the values of T'Class if
T has assignment.

> Consider replacing wheels in your car.

You should have annotated that example with types, values and variables.
 
>> You have to dispatch to finalize LHS. You
>> have to dispatch to re-construct it from RHS.
> 
> It doesn't change anything in my reasoning. Two linear dispatches
> don't magically give you double dispatch!

Of course it does. A function of two arguments is still a function of two
arguments. Decomposability of the function into a product is irrelevant to
the issue. It dispatches in both arguments.

>>> Assignment has to be '2D' with both axes, or O(n2) in terms of
>>> implementation complexity. It has to be double-dispatching to make any
>>> sense and this is unrealistic implementation-wise.
>>
>> It is semantically this way. There is nothing to do about it, but to scrap
>> either assignment or class. (We are going in circles)
> 
> That's exactly what I'm talking about from the very beginning -
> T'Class should be limited.
> Is it only my impression that we actually agree? :-)

Not at all. The point is:

limited T <=> limited T'Class

No more, no less.

> I'm talking about replacing wheels in my car. Twice a year I *replace*
> summer wheels for winter ones and the other way round. I *don't
> assign* them.

If you mean assignment of pointers, then pointers are typed in Ada. If the
pointers here have the same type (like P is access Wheel'Class) then there
is nothing to talk about. You assign P to P. That is just irrelevant to the
problem at hand. The issue is about assigning *different* types from a
class, like ones from Wheel'Class (Goodyear, Michelin), or like ones from
(access Wheel)'Class. Note brackets! The latter is illegal in Ada, but if
it were legal, you'd have exactly the same thing.

>> Then
>> because your types algebra has classes one could create a class of. In the
>> end you will face the same question again: what is the assignment on the
>> class. All this referential stuff is just shifting subjects.
> 
> No, it's not shifting subjects.

Of course it is, because the types are same.

The issue of identity / references you are trying to bring in is
irrelevant. Multiple dispatch assignment is fully applicable to wheel and
car objects. When you "replace" wheels, you could perform different tasks
depending on the types of the old and new wheels .How these tasks can be
encapsulated into one replacement action?

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