Re: Design By Contract

[mheaney@ni.net (Matthew Heaney)]

In article <VA.0000004d.486c7bde@nickle.compulink.co.uk>,
nickle@compulink.co.uk wrote:


>> For example Eiffel has direct support for multiple inheritance (MI).  Ada
>> requires you to play games with generic parameters in order to achieve
>> the same effect.

Thinking more about it, it really does make sense to implement mixin
inheritance this way in Ada 95.  The original poster probably wasn't
"thinking in Ada."  

To declare an abstract data type in Ada, you do this:

package P is

   type T is tagged private;
...
end;

Clients of type T with package P to get visibility to the type:

with P;
procedure Q is
   O : P.T;
...

Now as far as clients of T are concerned, it doesn't matter whether P is a
non-generic package, or the instantiation of a generic package.  His
manipulation of the type is the same.  For example, we could have done
this:

generic
   ...
package GP is 
   type T is tagged ...;
...

package P is new GP (...);

My point is that from a client's point of view, it's exactly the same.  He
wants a type that has certain operations, so he withs a package containing
that type.

Now we have a certain abstraction into which we want to mix some other
operations.  What we're debating is how easy it is for the _mixer_ to do
this.  But who made this executive decision that MI is a better mechanism
than genericity for combining abstractions?

The key thing is that we're able to combine abstractions this way,
_without_ an additional language feature.  (This doesn't mean MI is bad,
only that it's not needed.)  Existing language mechanisms do _exactly_ what
we want.  The irony is that this isn't anying especially new: in Ada 83 we
were _already_ combining abstractions this way (example: extending a list
type with utility operations by importing the list type as a generic formal
parameter).

To say that MI is a "more elegant' mechanism of implementing mixin
inheritance, or that Ada requires you to "play games" with generics (thus
reducing the Ada mechanism to the status of a mere "idiom"), is a pretty
impuissant argument.  (Like my new word?)  The generic technique is what
Ada programmers have been doing all along (though not quite as simply as in
Ada 95), so I'm not clear what you'd buy by using yet another mechanism
whose superiority is only putative.

--------------------------------------------------------------------
Matthew Heaney
Software Development Consultant
<mailto:matthew_heaney@acm.org>
(818) 985-1271