Re: Real OO

[mbk@caffeine.engr.utk.edu (Matt Kennel)]

James McKim (jcm@hgc.edu) wrote:
: In article <4nl9fj$35m@gaia.ns.utk.edu> kennel@msr.epm.ornl.gov writes:
: >Perhaps what you want is to be able to inherit implementation without also
: >inheriting interface, which in Eiffel, encompasses assertion as well
: >as routine signatures. 

: Hmmm... At first I thought these were orthogonal issues, but upon reflection
: I think you may be right. So class X has a feature f that has type
: semantics and implementation semantics. If we want class Y to be a subtype
: of X then any redefinition of f in Y is bound by the original type
: semantics. 

In Sather, if concrete class Y is a *subtype* (implying substitutability)
of X then X has no implementation. 

You can "inherit" some part of the implementation of X from
GENERIC_X_STUFF, MIXIN_HERE, and CETI_ALPHA_FIVE.  It matters not for
subtyping, as long as X upholds all the interfaces (supertypes) that it
is supposed to. 

: Now what happens if we want Z to be a subclass (inherit
: implementation of) X? I'm assuming that in Sather there is no restriction
: on how Z may redefine f, is that correct? And if W is intended to be
: both a subtype and a subclass of X then any redefinition of f must
: follow its original type semantics, but can implement it any old way.

Yes. 

: Yes, this is appealing....

: >
: >This is yet another reason to make such a design choice, either explicitly in
: >your language, or in your style of class design: keep distinct
: >'concrete leaf classes' which serve *only* as a locus of shared implementation
: >from 'abstract classes' which serve as specification.

: Lost you here. Are you talking about the subtype or subclass hierarchy?

Both, but I am advocating doing them separately, as suggested by the
"Design Patterns" book.

: If subclass, why would the leaves share implementation with their abstract
: ancestors? I would have expected abstract ancestors to be supertypes.

They are.

: If subtype, why mention the sharing of implementation at all?

They are distinct: the "shared locus of implementation class" 
has nothing to do with subtyping, but is a common idiom.

There is some far superior explanation on the Sather home page:

http://www.icsi.berkeley.edu/~sather

Look for the paper about the type & class system. 


: *------------------------------------------------------------------------------*
: Jim McKim  (860)-548-2458     Co-editor of Eiffel Outlook 
: Internet:  jcm@hgc.edu        Subscribe early and often!