Re: OO, C++, and something much better!

[Alan Lovejoy <alovejoy@concentric.net>]

Matthew Heaney wrote:
> 
> In article <E44u82.6uB@syd.csa.com.au>, donh@syd.csa.com.au wrote:
> 
> >:Where's the polymorphism of
> >:any form here?  Subtypes are ways of defining constraints (simple
> >:"assertions") on the possible values of the type.  Sub_Integer is not
> >:a new type and is not a type derivation.  So, you only have one type
> >:here (Re: RM: 3.2(8))
> >:
> >:The CE, is simply stating that you have violated the constraint
> >:(assertion).  No polymorphism broken or otherwise involved.
> >
> >Yes, if you define subtypes as such, then I concede it may be more reasonable
> >to regard this as simply an assertion violation and declare the type system
> >free of holes. It's a question of definition.
> 
> Precisely, Don.  It *is* question of definition, and we're comparing apples
> and oranges.  You may want to read any of Peter Wegner's papers, where he
> explains the difference between a "type" and a "class."
> 
> A type has "range" semantics.  Subtypes of the type constrain the range of
> values objects of the type can have.
> 
> A class has "template" semantics.  A subclass specializes the behavior of
> the parent.

There was a pretty big fight in c.l.st and comp.object over whether a Smalltalk 
class is a "type" about a year ago. Most profesional Smalltalkers maintained
that the two concepts are different.  A few others made the opposite case.

Of course, one is free to select any definition one cares to for the terms
"type" and "class."  The two sides were using different definitions for BOTH
terms, it turned out.  Wegner's definition of type is different than that 
used by either side in last year's debate.  Wegner's definition appears to
be based on type theory (nothing wrong with that).  

However, the type-theoretic notion of type is not the same as that commonly 
used in computer science and most programming language texts, where it is short 
for "data type." A data type defines the structure and interpretation of a section 
of computer memory, which indirectly defines a set or range of representable 
values--which may vary depending on the compiler/flags and CPU architecture used 
to compile and run the program (similarly, floating point numbers are not really 
the same thing as real numbers in mathematics--even though the former is meant 
to simulate the latter).  

The term "type" is also sometimes used instead of "abstract data type."  An 
abstract data type includes the concepts of information hiding and interface.  
The ADT still specifies the structure and interpretation of a section of computer 
memory--but it does so in such a way that the specification is hidden from all 
clients of the ADT, permitting the specification to change, perhaps even dynamically.
It does this by separating the specification of the interface to the ADT from
the specification of its implementation (both parts must exist in order to 
actually instantiate and use values of the ADT).

Also, an ADT specifies the interface of values of the type.  That is, it specifies
what functions/operators can be applied to values of the ADT.

I contend that classes in C++ (for example) are pseudo-ADTs with inheritance, a 
limited form of dynamic dispatching (virtual functions), but imperfect information
hiding.  Hence, a C++ class is effectively a type if one uses "type" as an alias
for "data type"/"abstract data type".

In contrast, a Java "interface" is a true ADT that also supports inheritance and
a less-limited form of dynamic dispatching.  A Java interface conforms to a
Smalltalker's concept of "type": the interface to an object (what messages one
can send and what will visibly happen as a result).

As for Smalltalk classes...well, we already had that debate last year :-).  But
I will say that a Smalltalk class resembles the hidden part of an ADT that specifies
a particular implmentation of the ADT.  Of course, more than one class can implement
that same interface--and the classes don't have to be related by inheritance...

> Jon is correct in pointing out that the example you gave is an example of
> the former.  Sub_Integer is a subtype (in the Wegner sense) that denotes a
> subset of the values of its parent.  There is no polymorphism, because we
> aren't dealing with classes (in the Wegner sense).

Good point.

> (Note that the term class as used by Wegner is not the same as the Ada 95
> meaning.  In Ada, a class refers to a family of types.)
> 
> And as far as your example "proving" that Ada is not type-safe: that is
> incorrect.  In fact the behavior proves just the opposite.
> 
> Constraint_Error was raised because the range constraint was violated.
> This behavior is similar to the Eiffel behavior when a precondition is not
> satisfied.  The terms of the contract between the client (the caller) and
> server (the subprogram) were violated by the client, so an exception was
> raised.  Isn't that what you would expect to happen?

Yep.  Just like what happens in a dynamically-typed language: a "message not
understood" exception is raised when an object with the wrong value is sent
a message it can't handle (the class of an object is part of its value in
a dynamically-typed language).

--
Alan L. Lovejoy		|==============================================| 
Smalltalk Consultant	|	Beware of Geeks bearing GIFs!	       |
alovejoy@concentric.net |==============================================|