Re: Classes vs Tagged Types - Terminology

[bevan@cs.man.ac.uk (Stephen J Bevan)]

In article <1993Mar30.143446.20879@inmet.camb.inmet.com> stt@spock.camb.inmet.com (Tucker Taft) writes:
   >In article <1993Mar25.155650.16244@inmet.camb.inmet.com> 
   >  stt@spock.camb.inmet.com (Tucker Taft) writes:
   >   [ much that I agree with except for the following ]
   >   More important than inheritance (even with type extension), 
   >   in my view, is the ability to have multiple implementations of 
   >   a given abstraction.  This is what separates an "object-oriented"
   >   language (like Ada 9X or C++) from an "abstraction-oriented"
   >   language (like Ada 83 or CLU).  In an "abstraction-oriented"
   >   language, each abstraction interface has exactly one implementation,
   >   and hence all calls on operations of the interface can be
   >   statically bound.  
   >
   >One of my favourite languages, ML, allows multiple implementations of
   >a single interface via parameterisation and to some extent so does
   >Ada83 via generics.  Can this be reconciled with the above statement?

   Good point.  However, a compile-time parameterized 
   abstraction, as embodied by an Ada 83 generic, 
   cannot provide the dynamic flexibility of the run-time
   polymorphism of object-oriented languages, where each object
   at run-time identifies its own underlying type.

But I never claimed they did.  My one objection to the paragraph I
quoted was the characterisation of the difference between
object-oriented and abstraction-oriented being that the former allows
multiple implementations per interface and the latter only allows one.
In the followup you seem to change your position to "self identity"
being the important feature of an "object" claiming to be
object-oriented :-


   I don't know the full details of ML's support for parametric
   polymorphism.  If the objects are self-identifying at run-time, then
   I would consider it "object-oriented" in the above sense.
   If not, implying that defining heterogeneous linked data
   structures is more painful, then it is an "abstraction-oriented"
   language based on the above definitions.

I'm probably being pedantic, but I always think of a hetrogeneous list
as allowing a mixture of types rather than different types derived
from a single root.  Has a term been coined for the pseudo
hetrogeneous structures that most OO languages allow or is the word
"hetrogeneous" forever lost?

bevan