Re: Invoking Inherited Routines in Ada9x

[elroy.jpl.nasa.gov!swrinde!cs.utexas.edu!mars.tsd.arlut.utexas.edu!larry@ ames.arc.nasa.gov (Larry Maturo)]

In article <9112051716.AA04270@merengue.mpr.ca> ssmith@MPRGATE.MPR.CA (Shaun Sm
ith) writes:
>
>   I'm not a member of the mailing list, but since ``Dear Ada'' isn't
>entertaining 9X questions as yet she/he recommended I mail to it to find
>an answer to my question.
>
>  In Ada9x, does 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?
>
>Here's the scenario in C++:
>
>eg.     class A {
> 	  virtual void foo(); // virtual means can be redefined by subclasses
> 	}
>
>	class B : public C {
> 	  void foo(); // "virtualness" inherited
>  	}
>
>	class C : public B {
> 	  void foo(); // "virtualness" inherited
>  	}
>
>
>	// In class C implementation file
>	void C::foo() {
>	   B::foo(); // must qualify the inherited member function with the
>		     // name of the parent which defines it.
>	}
>
>
>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).
>
>Back to my question.  I've had a look through the Ada9x documentation
>and can't find anything about how this will be done.   One person
>familiar with Ada suggested that perhaps the package name could be used
>to specify which class's implementatation of "foo" was desired.  This
>suffers from C++`s problem.  In addition, isn't is possible to define an
>arbitrary number of classes within a package.
>
>If someone knows the answer, or which document and section to look in,
>please let me know (by email since I'm not on the list).  I'm just
>trying to get a handle on how Ada9x approaches support for
>object-oriented programming.
>
>       Shaun
>
>Shaun M. Smith                  | ssmith@mprgate.mpr.ca
>MPR Teltech Ltd.                | mprgate.mpr.ca!ssmith@uunet.uu.net
>8999 Nelson Way, Burnaby, BC    | ssmith%mprgate.mpr.ca@relay.ubc.ca
>Canada, V5A 4B5, (604) 293-5345 | 
>


I have heard somewhere that Ada 9X might have handle object oriented things
the way Oberon 2 does.  If so, in Oberon-2 the above is handled by using a
caret after a routine name to refer to it's anscestor routine so the above in
Oberon 2 would be something like the below (note: I have never programmed in
Oberon-2 so this is approximate at best):


TYPE A : RECORD (* The base type *)
           I:INTEGER;
           B:BOOLELAN;
         END;

TYPE B : RECORD (A) (* Extends A *)
           R: REAL;
         END;

TYPE C : RECORD (B) (* Extends B *)
           C : CHAR;
         END;

PROCEDURE foo (p1:A) (parameter list for foo); (* This foo bound to TYPE A *)
BEGIN
  ...
END foo;


PROCEDURE foo (p2:B) (parameter list for foo); (* This foo bound to TYPE B *)
BEGIN
  ...
END foo;


PROCEDURE foo (p3:C) (x:A); (* This foo bound to TYPE C with parameter of type 
A *)
BEGIN
  foo^(x);  (* This invokes the foo bound to TYPE A *)
END foo;



I'd be interested to see if Ada 9X is indeed implementing OOP this way.  Any
comments?

+-----------------------------------+----------------------------------------+
|                                   |                                        |
| Larry Maturo                      | Opinions expressed herein must be      |
| Applied Research Laboratories     | yours, neither I nor my employer have  |
| University of Texas at Austin     | any.                                   |
| P.O. Box 8029                     +----------------------------------------+
| Austin, Texas 78713-8029          |                                        |
|                                   | When you're as great as I am it's hard |
| larry@titan.tsd.arlut.utexas.edu  | to be modest, but I succeed where      |
|                                   | others fail.                           |
+-----------------------------------+----------------------------------------+