Re: Access types as parameters

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

Dmitry A. Kazakov wrote:
> On Sun, 16 Aug 2009 12:52:53 +0300, Niklas Holsti wrote:
> 
>> Are you saying that any inspection of the tag of an object is 
>> "bad design", except for the case of "basic" dispatching?
> 
> With a high degree of probability it is. In all cases I have to check tag I
> feel myself guilty.

Me too. But it is sometimes the best solution (in Ada 95 at least), 
although it may cause maintenance problems.

>> Although I sometimes do it, I don't much like to inspect tags, as in Foo 
>> above, because it couples the logic of a class-wide operation to the 
>> existence and properties of certain explicitly named sub-classes, which 
>> is fragile. But a redispatching call is not fragile in this way.
> 
> It is fragile because it has a behavior that is not determined by the
> values attributed to the type T. Its behavior is determined by the values
> of T'Class, which is an open-ended set.

No. That argument makes *any* class-wide operation (using dispatching) 
"fragile", because "its behaviour is determined by the open-ended set" 
of operation implementations. We must accept this kind of "fragility" if 
we use dispatching at all.

I persist in seeing no extra fragility in redispatching.

>>> Re-dispatch is a hack. What do you do is
>>> semantically not inheritance but overriding with an instance of a generic
>>> body, or some class-wide body. I think this is the key issue. 
>> I'm sorry, I don't understand why it is "semantically not inheritance". 
> 
> Type S inherits F from T by composition of T.F with a type conversion:
> 
>    S.F = T.F o S_from_T

I think you have the conversion the wrong way around: If S.F should 
apply to an object X of type S, then X must first be converted to T, and 
then T.F applied:

    S.F = T.F o T_from_S

meaning that

    S.F (X) = T.F (T_from_S (X))

> That is the only way to define it in a typed language where S and T are
> distinct types. This is also how Ada defines it. Any primitive operation
> gets "re-declared" when you derive S from T.

Yes, yes, but Ada and other OO languages preserve the ability to 
redispatch, which does not fit into this simple mathematical 
functional-composition formalism. But then, we agreed that we use 
different formalisms, so all is OK.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .