Re: Interesting containers problem.

["Randy Brukardt" <randy@rrsoftware.com>]

I wrote:

...
> What you are talking about would help in an antique language that doesn't 
> support any overloading, but I would hope that people in this group are 
> beyond that. :-) If anything, Ada doesn't have enough overloading (too 
> much reliance on scopes, something that should have almost no bearing on 
> visibility).

It strikes me that there is an easy way to use the containers for a purely 
scoped language without any overloading. There's some overhead with scope 
exit (but that seems necessary in any case). The basic idea is to use 
cursors to link nested items together, and have the map point at the 
currently visible item:

   package Symbol_Tree is new Ada.Containers.Indefinite_Multiway_Trees
       (Element_Type => Symbol_Root'Class);

   package Identifier_Map is new Ada.Containers.Indefinite_Hashed_Map
        (Element_Type => Symbol_Tree.Cursor,
         Key_Type => String, -- Probably really a UTF8_String,
         Hash => ..., Equivalent_Keys => ...);

For this to work, each item in Symbol_Root'Class needs a 
Previous_Declaration component that also has type Symbol_Tree.Cursor. That 
points at the previous item (if any) that was visible before the current 
one.

A new declaration updates the map to point at itself in the symbol table, 
but not before squirreling the previous item (if any) into 
Previous_Declaration. When a declaration goes out of scope, the map has to 
be updated to put again at the Previous_Declaration (if any). This is 
essentially the same way one would write such a symbol table with access 
types.

Such a pure scheme doesn't work for module visibility (i.e. use clauses in 
Ada), because there can be multiple items visible at once that way. But I 
suppose that a very simple language might make it work (no overloading, no 
modules or at least only dot notation for modules). Janus/Ada worked that 
way initially (when doing the Pascal subset), but that didn't last long for 
obvious reasons.

                                   Randy.