Re: Ada Interfaces and the Liskov Substitution Principle

[Maciej Sobczak <see.my.homepage@gmail.com>]

On 24 Maj, 10:02, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:

> > Can it be dispatching on both arguments?
>
> It shall be. It is a pity that Ada does not have MD.

Yes, but that would not automatically solve the problem, see below.

> > Coming from C++, I have never seen any single example where assignment
> > made sense with polymorphic hierarchies.
>
> Real-life example. Consider a threaded library. Let you have an Ada-like
> rendezvous. You wanted to propagate an exception raised in the callee to
> the caller. Similarly, let an exception is propagated out of a child
> thread. You want to continue its propagation to the parent.
>
> > Do you know any such example? Can you show it?
>
> Marshaling objects.

No, I'm not convinced. This is more like cloning.

Assignment of class-wide type is strange/dangerous, beucause it might
require dynamic change of the object's type.
Assigning Circle to Triangle (through Object'Class) cannot reasonably
work with preserving the types of each object. The Triangle would need
to become Circle - and this action might change the ability of the
object to respond to messages that are supposedly in its interface. Or
change the invariants in the original type.

declare
  C : Circle;
  T : Triangle;
begin
  Do_Something(C, T); -- T := C; inside

  -- and here some code still thinks that T is a Triangle,
  -- which according to its declaration in the same scope
  -- must be true (but isn't!)
end;

There is no way to change the type of T in the code above and without
it there is no way to execute the assignment.
You can restrict the operation so that the arguments must have the
same tag (and then MD is not needed anymore), but such restriction can
be run-time only and cannot be expressed in the signature of
Do_Something.

Your marshalling example is interesting, but actually works
differently: you don't have the left-hand object before assignment;
you just make a copy of something and give the copy some identity.
It's just a copy-construction basically, or cloning (if polimorphic).
You can do this either with access variables or with initialization of
class wide type (which is *not* an assignment).

I was talking about real assignment - and this assumes that two
objects already exist and we make one to be equal to the other. There
is no way to do it right.

--
Maciej Sobczak
http://www.msobczak.com/