Re: Eiffel and Java + Ada dispatching

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

Robert A Duff writes:

:Don Harrison <donh@syd.csa.com.au> wrote:
:>...What would be clearer and less confusing, 
:>IMO, would be to declare the parametric information in a type together with 
:>the operation so that when you instantiate (explicitly) with that type 
:>(or a descendant type), you get the right operation with it. This way, it's 
:>very plain what the actual instantiation parameters are.
:>
:>Not sure how you would write this in Ada.
:
:This feature exists in Ada 95.  

Yes. It was good to see it included. The ability to use a tagged type as the
formal parameter is especially useful. This mechanism is analogous to 
constrained genericity in Eiffel:

Ada                                             Eiffel
---                                             ------
generic                                         class X [T -> Some_Type] ...
  type Some_Type is tagged limited private;
package X ...

For Ada, X could also be a procedure or function.
 
:Look up generic formal derived types in
:the reference manual.  Basically, you declare in the generic that the
:actual will be derived from some particular type, so inside the generic
:you can call the operations inherited from that type, and at the
:instantiation point, the compiler checks that the actual is in fact in
:the correct class.  

Yes.

:Programming by contract and all that good stuff.

Yes, This is true of Eiffel. You get the benefit of all the contracting
defined in the type (and transitively, it's subtypes). But, you don't get
this in Ada as it does not support Programming by Contract in the more 
general (and usual) sense.


Jon Anthony writes:

:That's one of the "typical" uses for generic formal package parameters.  It
:is one of the reasons they were included.
:
:    generic
:        type Some_Type is tagged private;
:        with function Some_Op (...) return Some_Type;
:    package X is end X;
:
:
:    generic
:        with package IX is new X(<>); -- No added constraints on Inst. of X
:    procedure Generic_Op(...);
:
:
:    package IX is new X(My_Type);
:    procedure Actual_Op is new Generic_Op(IX);
:
:An obvious variant that may prove useful in making sure things "line up"
:correctly would be:
:
:    generic
:        type Some_Type is new My_Type with private;
:        with package IX is new X(Some_Type);
:    procedure Generic_Op(...);
:
:Here, any supplied instance for IX must have been obtained via My_Type or
:one of its descendants.

Thanks for the example. 

Sounds like a good argument for unifying module and type. :)  (No, I don't
want to debate that one again).


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