Re: Adding "()" operator to Ada 200X

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

"Matthew Heaney" <mheaney@on2.com> wrote in message
news:1ec946d1.0306040928.6eb47667@posting.google.com...
> The problem is what type to return.  In C++ I do this:
>
>   T& operator[]();
>   const T& operator[]() const;
>
> The operator returns a reference to T.  There are no reference types
> in Ada, so it's not obvious how the language would be able to provide
> it.

I debated whether the right solution was to introduce some notion of
reference types to Ada, so that the "()" functions would be declared
something like this:

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

This would parallel the C++ approach, and has worked very well in that
realm. It occurred to me, however, that the reference type approach is
assumes that in an object of a array-like type, each component is
represented as an aliased section of memory of type Component_Type. One can
easily think of many situations where this would not be the case:

    - the components might be stored in the array-like object in a packed
format, so that they cannot be aliased;
    - the array-like object may be implemented using a file or database, so
that the components are not in memory;
    - the components may be stored in some alternate representation;

The reference type approach breaks down in these cases. As an alternative, I
proposed separate "()" and "():=" for retrieving and assigning components in
an array-like object.

    -- Function used to evaluate Source( Index )
    function "()" ( Source : in Array_Like_Type;
                    Index  : in Index_Type )
       return Component_Type;

    -- Procedure for assigning Value to Source( Index )
    procedure "():=" ( Source : in out Array_Like_Type;
                       Index  : in     Index_Type;
                       Value  : in     Component_Type );

This approach makes very minimal assumptions about our array-like types:
that we can retrieve a component from such an object given an index value,
and that we can assign a component value at a given index. These assumptions
would hold for virtually any type for which one would care to use the array
notation. Moreover, the "()" and "():=" proposal does not require adding
reference types to Ada.