Tree structures are interesting. Often the root of the tree is used as a
handle for the tree itself. However, the tree often has additional
methods beyond that of the root node.

I couldn't figure out how to do this simply via inheritance due to
chicken-and-egg problems with namespacing:

  class Tree < Tree::Node
    class Node
    end
  end
  #=> chicken-and-egg.rb:1: uninitialized constant Tree (NameError)


I came up with two alternative techniques to achieve the same goal. I'm
not wild about the way either are handled by RDoc (though the first is
substantially better):

  # Technique 1: Using modules
  class Tree
    module NodeStuff
      #...all the meat here...
    end
    include NodeStuff
    
    class Node
      include NodeStuff
    end
  end

  # Technique 2: Conjur the chicken first, and kill it later
  class TmpTreeNode
    # ...all the meat here...
  end
  class Tree < TmpTreeNode
    Node = TmpTreeNode
  end
  Object.class_eval{ remove_const( :TmpTreeNode ) }


Ideally, IMO, Ruby would let me do this:
  # No "Tree" module or class has yet been defined;
  # it is a pure namespace at this point
  class Tree::Node
    # ...all the meat here...
  end

  # Now Tree is a class
  class Tree < Tree::Node
  end


I don't have any question, and it's not important enough to me to make
an RCR for the above. I just thought I'd share these thoughts with the
world.