package dependence question

[Carl Banks <oaf@psu.edu>]

Okay, when I program, I like to construct large, dynamic tree
structures.  I like my trees to be traversible in any direction, so if
you're sitting on a node, you can access its parent or any of its
branches.

So let's say that a particular tree has a different type of node at
each level.  For example, type A is the root of the tree.  Its
branches are of type B.  B's branches are of type C, and so on.

Let's also say that A, B, and C are not really similar (they are only
similar in that they are in the same tree structure, but bear no
internal resemblance to each other).  A, B, and C really belong in
separate packages.

However, packages can't with each other, meaning that types A and B
can't store access types to each other if they are defined in separate
packages.  It seems that I have to choose between making the tree
traversible in only one direction, or defining A, B, and C in the same
package.

The best solution I could come up with myself is to make A, B, and C
child packages of a package such as Node, and declaring the types A,
B, and C (and their access types) in the Node package, while declaring
functions and procedures in the child packages Node.A, Node.B, and
Node.C.  This is somewhat messy, as it leaves the fields of type A
open to package Node.B, but at least it isolates the functions and
procedures.

My question is, is there a better way to define such a doubly-
traversible tree, so that different node types need not be defined in
the same package?

Thanks.

 
-- 
        ___\___         ____\___
    \  /      .\    \  /       .\
    |><  Carl  <    |><  Banks  <
    /  \_____)_/    /  \______)_/