Re: ADA.STRINGS.INDEX_ERROR : a-strunb.adb:782

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On 2018-01-20 01:42, Randy Brukardt wrote:
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
> news:p3sbkb$1msl$1@gioia.aioe.org...
>> On 19/01/2018 02:10, Randy Brukardt wrote:
> ...
>>> The benefit is that these things can express ideas that aren't possible
>>> for
>>> ordinary subprogram calls.
>>
>> That does not justify special syntax. E.g. initialization cannot be
>> expressed as a subprogram call either, nevertheless there is no special
>> syntax for declaration of objects with non-null initialization.
> 
> ??? ":=" is the special syntax of initialization (it's not the syntax of a
> subprogram call!). Your example seems to prove my point. :-)

I meant rather this:

    type T is new Ada.Finalization.Controlled with ...

    X : T;
    Y : Integer;

>>> To express Subtype'First as a function, one would
>>> have to have some sort of meta-type (a subtype parameter).
>>
>> I don't think this is related.
>>
>> (However I am glad that you begin to see subtypes as proper types. (:-))
> 
> A type parameter clearly would have to pass the subtype information as well,

Yes, like it does with array bounds, *if* it were a subprogram proper. 
This is irrelevant because it is not a subprogram, it only has a syntax 
of a subprogram call. But for the compiler it is a special case exactly 
like it is when the attribute syntax is used, or any other syntax. The 
detection does not require special syntax, that is the point. Once the 
compiler detects the case, the magic starts to work.

> since Ada does not allow naming of types. In this case, it is the subtype
> information that is most relevant. So I don't see your point or joke.

It was frequently argued that subtypes are not types but something, 
well, something...

> (And I
> don't see why you don't think it is related, either. One has to have some
> mechanism for getting this information, and if you eliminate the special
> mechanism for that, some replacement is needed. In the proposed language,
> only a subprogram call is available, unless some other special syntax is
> invented, which is just kicking the can.)

It is the same mechanism used to pass/eliminate array bounds. It could 
be generalized for all types including non-tagged classes. The type tag 
of a non-tagged type is a [sub]type constraint to be passed or not. The 
same case is represented by dimensioned values. The dimension is a 
constraint, again passed or not down to the subprogram, kept or not in 
an instance.

I think it is possible to design common rules for all this and make the 
language quite simple.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de