Re: Inferring array index type from array object

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

Peter C. Chapin wrote:
> Niklas Holsti wrote:
> 
>> I don't think such large language changes would be necessary. The 
>> expression S'Range gives the compiler all the information about the type 
>> and its constraints, so I see no reason why Ada could not be extended 
>> simply to allow S'Range in a variable declaration, as in the above 
>> quoted "I : S'Range". The declared variable "I" would have the same 
>> (sub)type as the loop counter in "for I in S'Range loop ...".
> 
> This seems weird to me. S'Range is a range, not a type. I agree that it
> includes type information, but then so does an object.
> 
> X : Integer;
> Y : X;       -- Let Y have the same type as X. Weird.

Another, perhaps more readable way would be to introduce some attributes 
that return types:

   I : S'Index_Type;

   Y : X'Type;

> Type inference is a big subject and while it can be very nice in languages
> that support it comprehensively, type inference doesn't really seem like
> the "Ada way" to me.

I would not call these examples "type inference", as they require no 
global or even subprogram-wide analysis. The desired type can be derived 
directly from what is written locally (and, of course, from the meaning 
of the identifiers).

> In any case, once you start supporting type inference in
> any form you have to wonder just how far down that road you want to go. Right
> now Ada only infers types in one very limited case (right?)... that is in
> support of implicitly declared loop index variables.

The type of implicitly declared loop index variables (for I in S'Range 
loop) needs only local analysis, so I would not call it type inference.

Resolution of overloaded subprogram and operator names is much more 
complex and could deserve to be called type inference. But even that 
requires only local analysis, although (I believe) it needs more than 
one traversal of the syntactic structure of the (nested) call.

"Real" type inference would be needed if these suggestions were extended 
to let variables be declared using the return type of an overloaded 
function call, with the overload resolution extended to take constraints 
from the use-sites of the variable. I won't try to give an example of 
that, as I agree with Peter that such non-local type inference would be 
against the Ada way.

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