Re: Visibility of Indexing aspects

["Randy Brukardt" <randy@rrsoftware.com>]

"Dan'l Miller" <optikos@verizon.net> wrote in message 
news:aeeb29f7-86d1-4b18-9312-03e1239f22b0@googlegroups.com...
On Wednesday, July 25, 2018 at 7:12:24 PM UTC-5, Randy Brukardt wrote:
> "Dan'l Miller" wrote in message
> news:3eebe2fb-f066-4248-9b2f-1db32497fd82@googlegroups.com...
...
>> ...
>> >The _LRM_'s forcing of {Reference, Reference_Holder, Container_Array, 
>> >...}
>> >to be public declarations ...
>>
>> ...is perfectly fine -- there's nothing wrong or dangerous with using 
>> them
>> directly. Indeed, "indexing" is just a shorthand for a longer call 
>> involving
>> Reference -- you're always allowed to make the longer call
>
>Yeah, unyieldingly demanding that unnecessary feature is the root-cause of 
>the
>violation of Steelman 3-5B detailed far below.

(1) No one reads any of your babble, simply because it is way too long for a 
"fun", non-required site. Say something consisely and stop! I struggle with 
this myself at times, but you're 10 times worse (which I didn't think was 
possible. :-)

(2) Steelman is only relevant (if it is relevant at all) for evaluating a 
new language design. Ada hasn't been a new design for decades --  
compatibility with existing code and existing Ada principles is what matters 
today. I cannot recall the last time that Steelman even came up in language 
discussions - there hasn't been a significant consideration of it in 
decades. (In part because it hasn't been updated in decades -- it predates 
OOP, for instance.)

(3) It's most important for a language to be self-consistent, rather than 
following some external model of purity. And it's definitely possible to 
hide too much.

(4) Ada doesn't really have user-defined indexing; it has some syntactic 
sugar that gives the illusion of user-defined indexing. The rules (static 
and dynamic) for it all stem from the underlying mechanism; it has rather 
little on its own.

Languages with true user-defined indexing existed before Ada; Ichbiah must 
have intentionally chosen not to include that feature. A language defined 
today around such a feature would be very different than Ada -- it probably 
wouldn't even have built-in array type. (An array is just another kind of 
container, and it's very inconsistent to have it be wildly different in 
definition than other containers.) Ada has so many bizarre rules around the 
use of built-ins that trying to reproduce it in a consistent way would lead 
to madness (dozens of special-case rules that exist only for compatibility). 
[Dmitry is right that it could be done, in the sense that anything can be 
done given enough money  and/or desire. But it wouldn't make any realistic 
sense to be done.]

I need to write that long-thought about blog entry outlining how I would 
change Ada given a blank slate. It would be something on the line of what 
Dmitry suggests, but almost all aspect-based (explicit interfaces are 
useless IMHO).

                                           Randy.