Re: Mut. Recurs. in Ada9X w/o Breaking Encaps.? (LONG)

[Magnus.Kempe@di.epfl.ch (Magnus Kempe)]

adam@irvine.com (Adam Beneschan) writes:
: ...  the package Company is there "just to get the Ada language to do
: what you want", not to represent any concept or abstraction that has
: anything to do with the application.

This is incorrect.  The requirement is for two ADTs which are mutually
dependent.  Ada 9X offers a hierarchical namespace which allows us to
capture the fact that Employee and Office belong together (you're not
going to use one without the other), and the root package Company _holds_
that mutual dependency.

: As I understand it, inheritance's primary purpose is to model "IS-A"
: or "IS-A-KIND-OF" relationships between object types (I believe it's
: sometimes used purely for code reuse, although that seems like a
: misuse of the concept to me).  Here, inheritance doesn't really model
: anything--it's just something that got set up in order to get things
: to work.

You are right that code usually doesn't "model" anything.  It's just
there to _implement_ a model.  You seem to hold that inheritance is
good only when it corresponds exactly to an "is-a" relationship of
your model.

But there are two kinds of inheritance: interface and implementation (or
code sharing).  The first corresponds to is-A relationships; the second
is a means for code sharing.  In the particular example you cite, the
derivation was not done in the interface but in the private part, so as
to _hide_ the inheritance.


Compare undue interface inheritance (the client sees the ADT and
implementation details, as well as some List stuff which has nothing
to do with a Stack ADT)

with Lists;
package Stacks is
  type Stack_Type is
    new Lists.List_Type -- !!! Stack is-a List
    with private;
  ... -- Push, Pop, Size
  
  ... -- somehow try to hide the operations of List_Type which
      -- violate the Stack abstraction
private
  type Stack_Type is
    new List_Type
    with null record;
end Stacks;


vs. implementation inheritance (the client does not see anything
except the proper ADT)

with Lists;
package Stacks is
  type Stack_Type is
    private;
  ... -- Push, Pop, Size
private
  type Stack_Type is
    new Lists.List_Type -- !!! Stack is-implemented-by-a List
    with null record;
end Stacks;


There is nothing revolutionary here, and nothing peculiar to Ada.  The
distinction between interface and implementation inheritance is quite
common and useful.  One may have a dislike for implementation inheritance,
but that's no sufficient reason to forbid its use to those who do find
it advantageous.  Is it an ugly "workaround"?  Maybe, to the extent that
someone somewhere will castigate any high-level language mechanism for
being a workaround of their favorite assembly language feature.

-- 
Magnus Kempe		"I know not what course others may take, but as for me,
Magnus.Kempe@di.epfl.ch  Give me Liberty... or give me Death!" -- Patrick Henry