Re: SOLVED! Decoupled Mutual Recursion Challenger

[jmartin@oahu.cs.ucla.edu (Jay Martin)]

With all these ugly workarounds it looks like we must have a
language extension to Ada to handle mutual dependencies.
Otherwise Ada9x is a "joke".  Of course if there is no way that Ada
will be extended quickly, it will be a "joke" anyway.  Hopefully C++
has taught language designers/standardizers something.


The extension would be of the form:

package forward X is
  type XType;
  type XPtrType is access XType;
end X;

And would be severely resticted to only allow for incomplete types
declaration and access types to incomplete types.  These of course
would have to be repeated/elaborated in the package spec.

Thus, there would be a third package part in Ada compilation libraries
(Spec and body being the other two).  What it does is tells the Ada
compiler to not give an error if these yet to be specified types are
used in a spec.  

So basically a programmer could compile the forwards first, then the
specs and finally the bodies into the Ada library.  (GNAT looney
tunes "#include the spec" implementation of the Ada library
would place all the withed package's forwards before their specs
when compiling.) 

Of course, you couldn't directly declare incomplete objects in the private
parts of specs.   An elegant way of handling this (which would
be too obese to put in ada) would be to have a separately compiled
"package representation" part of a package which would basically
remove the private part of spec out of the spec.  For example:

with X; 
package representation Y is
  type YType is
   record
     P1:integer;
     P2:X.XType;
   end record;
end X; 

Its neat because it removes implementation details from the spec 
where they never belonged and allows for mutually recursive types to
be directly included into the abstract data type (instead of having a
pointer to it).

Jay