Re: Ada.Locales pseudo-string types

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

On 12-08-08 11:28 , J-P. Rosen wrote:
> Le 08/08/2012 09:37, Niklas Holsti a �crit :
> 
>> But we are talking about explicitly requested type conversions, not
>> implicit type equivalence. As I understood it, at least.
> Yes, or more precisely, about the special rules for array conversions,
> which are allowed if the types are structurally "close enough".
>>
>>>> For a value conversion,
>>>> the default could be to convert element by element, and the compiler
>>>> could then optimize this conversion based on what it can deduce
>>>> statically about the matching of the source and target subtypes.
>>>
>>> Could be interesting when elements themselves are arrays of discriminated
>>> record subtypes constrained via discriminants with array components again
>>> constrained etc.
>>
>> Sure, but this should not require much new intelligence in the compiler.
>> An array type conversion of the form A1 := A1_Type(A2); could just as
>> well be written as an explicit loop with explicit element-by-element
>> conversions, A1(I) := A1_Element_Type(A2(I)). A compiler could do this
>> expansion internally, giving code that is legal today and which the
>> compiler should already be able to compile.
>>
> That's the whole point: a possible costly loop implicitely generated by
> the compiler. The design choice was to /not/ hide this, i.e. allow array
> conversions only when no extra code was required.

But such implicit loops can already be generated in several places, for
example in the assignment of array values and in the application of
relational or Boolean operators to arrays. So this design choice has not
been applied uniformly.

> You are free to disagree with that design choice, of course...

I don't agree or disagree; it is a trade-off between ease of expression
and simplicity of the resulting code. The all-or-nothing language design
choices of early Ada, e.g. the "no subsets" rule, have given place to
more flexibility, exemplified by configuration pragmas such as pragma
Restrictions.

In my professional area (worst-case execution-time analysis),
compiler-generated implicit loops are often a problem, especially in Ada
programs. A restriction identifier to forbid such loops (at least when
the number of iterations is dynamic) could be useful here, and would let
programmers choose between a restrictive or a permissive coding style.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .