Adding "()" operator to Ada 200X

["Frank J. Lhota" <NOSPAM.lhota.adarose@verizon.net>]

There appears to be wide agreement that Ada 200X should include some sort of
standard container library like Charles and PragMark. This library will
probably include generic packages for creating and operating with dynamic
lists and maps. One can view these kinds of collections as generalized
arrays, and as such, it would be nice to use array notation for accessing a
member of one of these collections. In other words, one should be able to
define the "()" operator for array-like types, as follows:

    function "()" ( Source : in Array_Like_Type;
                    Index  : in Index_Type )
       return Component_Type;

For example, if the object Roster is a list of objects of type Player_Type,
it would be quite desirable to be able to access the second player in Roster
as

    Roster(2)

For that matter, we could use the "()" operator to improve some existing Ada
packages. The Ada.Strings.Bounded and Ada.Strings.Unbounded packages define
the types Bounded_String and Unbounded_String that are enhanced versions of
the String type. If Item is of type Bounded_String / Unbounded_String, we
now access the third character of Item using the expression

    Element( Item, 3 )

Again, why not use the same notation that we would use if Item were declared
as Standard.String (assuming that Item'First = 1 ), i.e.

    Item(3)

If Ada 200X had an "()" operator, we could add the following declaration to
Ada.Strings.Unbounded

    function "()" (Source : in Unbounded_String;
                   Index  : in Positive)
       return Character renames Element;

With this declaration, we could use either "Element( Item, 3 )" or "Item(3)"
to get the third element of Item.

Of course, an array component can also be assigned a value, as in

    Item(3) := 'A':

For that reason, we may also want to add an "():=" operator that is used to
update a component of an array-like object, e.g.

    procedure "():=" ( Source : in out Array_Like_Type;
                       Index  : in     Index_Type;
                       Value  : in     Component_Type );

Again, we could enhance packages such as Ada.Strings.Bounded and
Ada.Strings.Unbounded by declaring a "():=" operator that could be used in
place of the Replace_Element procedures.

I cannot help but think that this would be of tremendous help with whatever
standard container library is added to Ada 200X.