Re: SOLVED! Decoupled Mutual Recursion Challenger

[jgv@swl.msd.ray.com (John Volan)]

beckwb@ois.com (R. William Beckwith) writes:

>John Volan (jgv@swl.msd.ray.com) wrote:

>: I would
>: argue that such a scheme falls into the trap of "inheritance
>: collision", where one usage of inheritance (providing alternate
>: programming-interface views for a single class of real-world entities)
>: gets in the way of the "customary" use of inheritance (supporting
>: generalization-specialization relationships between different classes
>: of real-world entities).

>It shouldn't because we are just added an intermediate level of
>inheritance between each "customary" use of inheritance.  

Doing that will work -- until we have to establish a mutually
recursive association between a class and *one of its own subclasses*.
That was the "acid test" that I posed in my original "Challenge".
Consider the Rooster class in my (admittedly bizarre) example.  The
Rooster class must somehow be "forward declared" before the spec of
the Chicken class so that the Chicken class can include Rooster-related
primitive operations. But ultimately, the Rooster class must *inherit*
from the Chicken class.  How can the Rooster interface be *derived* from
the forwarded Rooster declaration, *and* also inherit from the Chicken
interface?  This is what I've been calling "inheritance collision."

>But,
>the effect of this is that you don't achieve true decoupling.

Well, maybe we're using different definitions of "decoupling", because
I'd say that your original scheme *did* in fact achieve decoupling --
except that it breaks down when pushed to the limit, because of
"inheritance collision".  That's why I'd encourage you to use
generics for decoupling, rather than inheritance.

By the way, folks, an association between a class and one of its own
subclasses is *not* a rare or obscure occurrence, in fact it happens
all the time.  Consider, for instance, a file system, where a
"directory" is a kind of "file" that can contain other "files"
(including other "directories").  Another example is an
object-oriented drawing editor that allows "grouping" of drawable
objects.  A "group" is itself a kind of "drawable object" that
contains other "drawable objects" (including, perhaps, other
"groups").  There are many other similar situations.  Not all of these
associations have to be implemented in a mutually-recursive way,
necessarily, but being able to make even these associations mutually
recursive *and* decoupled is the ultimate test of any scheme for
decoupled mutual recursion, IMHO.

-- John Volan

--------------------------------------------------------------------------------
--  Me : Person := (Name                => "John Volan",
--                  Company             => "Raytheon Missile Systems Division",
--                  E_Mail_Address      => "jgv@swl.msd.ray.com",
--                  Affiliation         => "Enthusiastic member of Team Ada!",
--                  Humorous_Disclaimer => "These opinions are undefined " &
--                                         "by my employer and therefore " &
--                                         "any use of them would be "     &
--                                         "totally erroneous.");
--------------------------------------------------------------------------------