Re: Invoking Inherited Routines in Ada9x

[elroy.jpl.nasa.gov!sdd.hp.com!caen!uvaarpa!software.org!blakemor@ames.arc .nasa.gov (Alex Blakemore)]

In article <9112051716.AA04270@merengue.mpr.ca> ssmith@MPRGATE.MPR.CA (Shaun Sm
ith) writes:
>  In Ada9x, does [sic] you know how a subclass subprogram can invoke the
>subprogram with the same name defined by an ancestor.  This is achieved
>in Smalltalk by sending a message to "super".  By sending to "super"
>rather than "self", the next implementation of a method in the
>inheritance hierarchy is invoked rather than the one supplied by the
>class of the current object.  Is that clear?

This is described in the mapping rationale document version 3.1
August 1991.  An example in section 4.2.3.1 pages 4-10 to 4-11
shows how to call a subprogram can invoke the subprogram which
it is overriding using explicit type conversion.
An abbreviated version follows (I have left out some lines,
but added none other than comments):

package new_system is
  type alert is tagged  -- dispatching (polymorphic?) type
    record
      message : text;
    end record;
  procedure handle (A : in out alert);
end new_system;

with new_system;
package medium_level is
  type medium_alert is new new_system.alert with -- Ada9X type extension
    record
      action_officer : person;
     end record;
  procedure handle (MA : in out medium_alert);
end medium_level;

package body medium_level is
  use new_system;
  procedure handle (MA : in out medium_alert) is
  begin
    handle(alert(ma));  -- calls new_system.handle
    ma.action_officer := assign_volunteer;
  end handle;
end medium_level;

For more info read the mapping rationale and mapping specifications
douments from ajpo.sei.cmu.edu (read the rational first)

>C++'s solution to this requirment results in brittle code since one has to
>specifically identify the parent class which supplies the next most
>specific implementation of a member function (method).

Ada's solution seems similar to C++'s in that the subclass must
name the superclass to invoke the parent method (using OO speak)
I assume you find that brittle because it makes it difficult
to rearrange the inheritance hierarchy ? perhaps to add a new 
intermediate level.

On the other hand this solution fits with Ada83 syntax and
semantics well.  Explicit type conversion allows the Ada83
overloading to resolve at compile time which subprogram to invoke.

If you have a better suggestion, post it to or
send it to the people who can do something about it at
ada9x-mrt@inmet.inmet.com

The mapping rationale claims near the end of that section:
"Each body for HANDLE encloses just the code relevant to the type,
and delegates additional processing to an ancestor with explicit
type conversion.  This is more flexible than the super pseudo-variable
of Smalltalk-80 and retains static type checking."

>In addition, isn't is possible to define an
>arbitrary number of classes within a package.

Yes just as it is possible to declare an arbitrary number
of types within a package.  Sometimes that is useful, but that
doesnt mean it is always good design.  I always try to put one
ADT per package as a rule of thumb, perhaps with some supporting types.
I imagine adding inheritance wont change that.

By the way, a type class in Ada9X is SET of types
which share common operations and are organized in a class
hierarchy (tree).  This is different than the normal OO
definition of class which corresponds mode closely to an
Ada9X type.
-- 
---------------------------------------------------------------------
Alex Blakemore           blakemore@software.org        (703) 742-7125
Software Productivity Consortium  2214 Rock Hill Rd, Herndon VA 22070