Re: Teaching new tricks to an old dog (C++ -->Ada)

[Georg Bauhaus <sb463ba@user1.uni-duisburg.de>]

Ioannis Vranos wrote:
> Georg Bauhaus wrote:
> 
>> One difference is a 1:1 correspondence of index values and
>> indexed items. This suggests not using p[-1] or somearray[1]
>> interchangeably:
>>
>> There is one named index type.
>> There is one named array type.
>> The index type is used in the declaration of the array type,
>> stating the set of permissible array index values.
> 
> 
> 
> Again, one can easily define an array container that accepts user 
> defined indexes.

I have not seen one so far, only some handcoded range checking,
which is not the point. Handcoded range checking does not replace
the definition of a type in terms of two other types. Note carefully:
types. Range checking is not the same thing as a type. Neither in
source text read by a human, nor in source text read by a compiler.
Whatever the language is.

In C++ terms:

namespace Adalike {

  template  <typename T, typename Index>
  class vector {
       ...
  };
}

Can you see the essential and important difference?
Just like std::map, Adalike::vector has two (!) non-default
parameters: one for the item type, the other for the index
type. This is the essential difference between std::vector
and Adalike::vector.

The compiler will use the information present in Index
to establish properties of the Adalike::vector type such that
Adalike::vector indexing (an operation) is based on properties
of Index (Index is a type! It is not an algorithm base on min
and max int parameters).

This has something to do with making the base types int, long, etc.
class types. When they are class types, you can invoke their
methods, derive other number types, and then you can use
their interface to build an array that is using the information
provided by int or provided by a type derived from int.

Ada:

   type Year_of_Interest is new Integer range 1815 .. 1914;

   type History is array (Year_of_Interest) of String;


It is not possible to express this using types in C++:

   class Year_of_Interest : int {  // Not C++
     ...
   };

   typedef array<Year_of_Interest, std::string> History;

(Because there is no such thing as array<typename Index, typename T>
in STL afaik. Association is characteristic of map, not of vector
etc. This is different in Ada, where association is readily availably
by associating an index type with an array in an array type
declaration.)


> The philosophical question that arises is *why no one 
> has done it to this day*.

It has been done for associative containers only. It could be done for
array-like containers if C++ had introduced the base types as base
classes.

> However I am going to make such one in some weekend (perhaps this!) to 
> see if I can find any real use of it. Doing it sounds really simple:
> 
> 
> template<class T, const int MIN, const int MAX >

A solution will have this parameterization and checks:

   template<class T, class Index>
> class Array: public vector
> {
>  //  Only provide definitions for operator at() and operator[] that
>  //  really *only* explicitly call the base ones with the proper index.
>  //  And the few constructors doing the same, *only* explicitly passing
>  //  the *same* arguments to the base constructors.
    //   Check indexing precondition Index::contains(v) in at(v) and
    //  operator[](v).
> };

> I think it is *that* simple.

O.K., I'll wait.

> For more diverse things, maps are suitable (I guess in Ada too).

Maps are not needed here, in Ada and other languages supporting
different kinds of arrays. For example, why should I use

   std::map<someEnum, T>,

when I can use something much more efficient to express the
same concept, and still the thing is an array, technically?
In pseudo-C++ terms, Ada *does* provide

   std::valarray<someIndex, T>  (Yes, 2 parameters here!)


>> (Ada-like arrays have STL's key_type so to speak.)

> key_type is used only in maps!

In Ada, key_type *is* used in arrays, because that's a feature
provided by the language.

This is what I'm trying to explain.


Georg