Re: Eiffel and Java + Ada dispatching

[donh@syd.csa.com.au (Don Harrison)]

Robert A Duff writes:

:>:>  type Some_Type is tagged limited private;

:>:I meant "type Some_Type is new Other_Type with private".

:In the first example above, Some_Type doesn't have any primitive
:operations.  You can't do much of anything with it, other than declare
:objects and a few other minor things.  (Unless you pass in explicit
:operations, which is what you (or somebody else?) was objecting to,
:several messages ago.)

I don't remember objecting but *was* curious about why operations had to be
explicitly declared as parameters along with types under some circumstances. :)
I expect this is a legacy of Ada-83.

:In the second example, Some_Type inherits all the primitive operations
:of Other_Type.  Inside the generic, you can do dispatching calls to them
:and so forth.  The actual type is required to be in the right class
:(Other_Type'Class), and thus implements all of those things you're
:calling.

This appears to be analogous to Eiffel's constrained genericity:

  class X [Some_Type -> Other_Type] ...

:I believe Eiffel has something similar to both, but I forget the syntax.

It has the 2nd type but not the first. This makes sense for Eiffel, IMO, 
because types potentially carry operations with them. These operations should 
be available wherever the type is used.

:Is this the "class X [Some_Type]" vs. "class X [Some_Type ->
:Other_Type]" thing?  You can have a generic class where the formal can
:be any class, or you can require the formal to be a subclass of some
:particular class.

That's right. The former is called 'unconstrained genericity'. As you would
expect, the operations also come with the type with this form.


Don.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Don Harrison             donh@syd.csa.com.au