Re: Ada Interfaces and the Liskov Substitution Principle

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

On 25 May 2007 13:27:47 -0700, Maciej Sobczak wrote:

> On 25 Maj, 10:21, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
> 
>>> Interesting. In most of the cases, the factory function creates the
>>> object of whatever type *it* decides (based on its parameters or some
>>> other input values) and initializes the class-wide type accordingly.
>>
>> Not necessarily. In one case, I generate nodes of a graph. The nodes can be
>> of different types regarding their persistence. For example, there are
>> nodes resident in the database and nodes resident in the memory etc. Now,
>> when creating a new node a factory moves along two axes: the standard
>> root/branch/leaf hierarchy and persistence stuff. For the latter the
>> factory receives an already existing node, to create "a new node like
>> this." This is not copying. Ideally it should double dispatching along both
>> axes. I have implemented it as:
>>
>>    New_Node := Create (Get_Factory (Some_Existing_Node), ...);
> 
> Above, it is the factory function that is "parameterized" on the left-
> hand type

and the right-hand one, which was the point. But it would be enough to give
just two examples, one for LHS, another for RHS:

   X : T;
begin
   X := Read_From_File;  --- LHS
  return  X; -- RHS in the caller

> - this is still much different from assignment_statement
> (wow!) between two class-wide types.

How is it different? Note that there is little room for how to define
assignment. Within a type hierarchy there are only four variants:

T'Class x T'Class  -- non-dispatching
T x T'Class  -- dispatches on the target (C++)
T'Class x T' -- dispatches on the source
T x T -- Fully dispatching (Ada*)

In all cases X:=Y will be legal on two class-wide objects.

> I'm still for banning it.

For this you have to make assignment contravariant (non-primitive
operation) in one of its arguments. That would be a total mess, because it
would require overloading assignment for each derived type.

For the same reason all signatures with a class-wide parameter are bad,
because they lead to ambiguities in trivial cases:

type S is new T with ...;
X, Y : S;

X := Y;  -- S'Class x S'Class vs T'Class x T'Class?

You will need some sort of dominance rules to resolve that.

P.S. Probably you have in mind a "stratified" assignment which statically
checks that LHS and RHS are of the same type. Ada has it as well. This is
achieved by types cloning upon derivation:

type My_Float is new Float range ...;
-- equivalent to
-- subtype Anonymous is My_Float range ...; -- Same hierarchy
-- type My_Float is new Anonymous; -- Clone it

Unfortunately, which IMO was a big mistake, this mechanism war prohibited
for tagged types.

-----------
*  Ada's assignment is doubly dispatching. The dispatching table is a
square, the diagonal of consists of thunks:

   Finalize (LHS);
   bit-copy (LHS, RHS);
   Adjust (LHS);

Non-diagonal elements are:

   raise Constraint_Error;

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