From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-0.8 required=5.0 tests=BAYES_00,INVALID_DATE
	autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 1108a1,93fa00d728cc528e
X-Google-Attributes: gid1108a1,public
X-Google-Thread: 103376,93fa00d728cc528e
X-Google-Attributes: gid103376,public
X-Google-ArrivalTime: 1994-10-24 11:51:44 PST
Path: 
 bga.com!news.sprintlink.net!hookup!swrinde!gatech!swiss.ans.net!europa.eng.gtefsd.com!news.umbc.edu!eff!blanket.mitre.org!linus.mitre.org!linus!mbunix!eachus
From: eachus@spectre.mitre.org (Robert I. Eachus)
Newsgroups: comp.lang.ada,comp.object
Subject: Mutual Recursion Challenge
Date: 24 Oct 94 11:49:25
Organization: The Mitre Corp., Bedford, MA.
Message-ID: <EACHUS.94Oct24114925@spectre.mitre.org>
References: <1994Oct18.221751.15457@swlvx2.msd.ray.com>
 <CxwAuy.1CL@inmet.camb.inmet.com>
	<38289r$79m@oahu.cs.ucla.edu> <1994Oct19.143843.372@wdl.loral.com>
	<38fi4r$l81@oahu.cs.ucla.edu>
NNTP-Posting-Host: spectre.mitre.org
In-reply-to: jmartin@oahu.cs.ucla.edu's message of 23 Oct 1994 22:53:31 -0700
Xref: bga.com comp.lang.ada:7206 comp.object:7741
Date: 1994-10-24T11:49:25+00:00
List-Id: <comp.lang.ada>

In article <38fi4r$l81@oahu.cs.ucla.edu> jmartin@oahu.cs.ucla.edu (Jay Martin) writes:

  > All in all this method seems to have alot of programming and
  > conceptual overhead.  Also there will probably have to be a
  > section in every decent Ada9x programming book explaining this
  > method.

    I hope not.

    There are many features in Ada 9X which lead to a better approach
to OOP.  In particular, the mindset problem here is that the mutual
recursion must be between peers.  Ada 9X does a nice job on recursion
between objects at different levels of abstraction, and most of
difficulty in the examples comes from constructing two types at the
same level of abstraction and in different packages.

    In my (so far limited, as is everyone's) experience in Ada 9X, you
are much more likely to be adding an abstraction, using a generic
mixins, when the need for recursion occurs.  In those cases, all the
baggage discussed is either there for other reasons or not necessary.
It may seem that creating a dozen abstract types which are only there
as placeholders is a problem, but in fact the only problem I have
found with it is coming up with names.  (The best strategy I have
found is to use the base class name joined with the generic package
name as the name of the package instance:

    package Persons_Office_Assignment is new Office_Assignment(Person);

    and elsewhere:

    package Office_Staff_Assignment is new Staff_Assignment(Office);

    As this particular instantiation should make clear, package
Staff_Assignment may also be used to add staff to projects, to
departments, etc.  And in fact it might be better to have the
assignment package defined as a double generic as a much higher level
and instanced down, or just as a generic with two type parameters as
suggested earlier in this discussion.  (In such a model, Person and
Office would be instances of Objects, and Assignment would create a
relationship.)

--

					Robert I. Eachus

with Standard_Disclaimer;
use  Standard_Disclaimer;
function Message (Text: in Clever_Ideas) return Better_Ideas is...