Re: Gnat GPL 2010 available soon (conditional expressions)

[Phil Clayton <phil.clayton@lineone.net>]

On Jul 6, 6:18 pm, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:
> On Tue, 6 Jul 2010 09:31:05 -0700 (PDT), Phil Clayton wrote:
> > The concept of an order is important because the function F could have
> > side effects in the above example (though I would not advocate that as
> > good practice).
>
> AFAIK, presently the order is not defined. So though this is legal
>
>    X : String (1..80) := (others => Character'Read (Stream'Access));
>
> It is not a good idea.

It would be good if the order was not defined because that would
prevent people depending on it, so making it easier for a compiler to
parallelize.


> > However, we would be able to write
>
> >   (for I in reverse A'Range => A(I))
>
> > to represent the reverse of the array A is perhaps a little confusing.
>
> The effect is undefined. Theoretically the compiler could initialize array
> elements concurrently on a multi-core processor.

There are really two concepts here:
1. the order of evaluation of the expressions for each index
2. the value the bound variable I gets for each index

I didn't make it clear that I was switching from [1] to [2], sorry.
This above reverse example was really about [2] to show that the use
of the keyword 'reverse' would result in I having the value A'Last at
index A'First, A'Last - 1 at index A'First + 1, etc.  I don't think it
matters whether A(I) is evaluated for each index in parallel, so I
think the expression should be well defined.


> > Also, it really only makes sense to have one variable holding the
> > array index.  For example, if we could write
>
> >   (I, J : 1 .. 5 => ...)
>
> > surely I and J would always be equal: there are only 5 elements in the
> > array.  Having
>
> >   (for I in 1 .. 5 => ...)
>
> > syntactically rules out multiple variables.
>
> Yes, but many other things as well. However I prefer an absolutely
> different approach anyway, e.g. proper index types. In my world a diagonal
> would be initialized like:
>
>    (Diagonal (5, 5) => 1.0, others => 0.0)
>
> where Diagonal is a proper function.

Interesting.. how would you make the expression a function of the
index?  For example, how would you write

  (for I in 3 .. 8 => A(I) + B(I - 2))

?

Phil