Re: A bad counterintuitive behaviour of Ada about OO

["J-P. Rosen" <rosen@adalog.fr>]

Le 08/08/2014 15:11, Dmitry A. Kazakov a écrit :
>> Yes of course, but the /theory/ of it, and especially group theory etc.
>> that you mentioned is not a programmer's concern.
> 
> How so? If integer is not ordered there is no "<" defined, if there is no
> "<" how are you going to have an ordered map with integer keys?
Well, of course the computer Integer has "<", but to use it I don't need
to know (nor do I give a damn) that it is a group, and that other types
are also groups.


>> A generic can be applied to types that are not related in any way.
> 
> They are related in exactly the way that this generic can be applied to
> them. Is the feature of being applicable in a generic relevant for
> programmers? I think it is. 
The point is that of logical dependency. If I have a type T, and want to
use an operation defined on class C, I have to make my type a member of
C. And C has other members, that become somehow the brothers of T. LSP
means that they can be interchanged in some situations.

With a generic G, of course T has to match the contract imposed by the
formals of G, but there is no connection to other types that may
instantiate the same generic.

Now, you can define the "class of all types that can instantiate G".
Possible, but useless.

>> This reminds me of a (bad) example of inheritance I once saw in a book:
>> the class "parrot" inherited from the class "human" because it needed
>> the method "can_speak". I'm somewhat uncomfortable with the notion that
>> a parrot is a special kind of human ;-). Well, it's a bad example
>> because inheritance should not be used just to grab any method you need.
> 
> It is bad design, because the class of things that can speak is not the
> class of humans. Parrots and humans certainly participate in some classes,
> e.g. in Chordates, Tetrapoda etc.
The point is that often people write a method on a class, and then
inherit from it because they want to reuse a method. Inheritance is used
for "uses" relationship, not for "is-a". It is an abuse of inheritance,
but very frequent (even in basic Java classes).

> This is exactly the point why generics are untyped in their heart.
In the sense that they can be applied to any kind of type that matches
the contract, yes. And that's a good thing.

> There is
> tight relationship between operations =, /=, <, >, >=, <=, 'Prev, 'Next of
> an ordered set. This is what makes it such a thing. Inheriting to Ordered
> tells to the reader all this in just one source line. Moreover, it allows
> the compiler to check if the manifested type is indeed ordered and even
> prove some of this like x=y <=> not x/=y. 
Certainly not. Inheriting from Ordered guarantees that all these
operations are available, but say nothing about the semantics. If you
want to add semantics, use type invariants and the like.

> Compare this with generics. They
> just name some operations and the programmer should guess about the purpose
> of what the actual type should be. Yes there is no dependency ... on the
> application domain. Just an ad-hoc mess.
> 
It's not a mess. It's generality. The actual type should be anything
that matches the contract.

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr