Re: Lower bounds of Strings

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

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:rt6ltg$922$1@gioia.aioe.org...
...
> No, one should have interfaces for such operations as well.

You're again losing sight of the ultimate goal here, which is to have a 
conventionally compiled language that works close to the metal for high 
performance. (And is compatible with embedded systems, runable from ROM, 
etc.)

Interfaces of any kind are completely counter to that goal, *especially* in 
the case of arrays/vector containers.

Any sort of multiple inheritance (not to mention multiple dispatch) requires 
searching a lookup table for the appropriate interface. That is unaccepably 
expensive for an operation as basic as array indexing. One could use 
just-in-time compilation and similar techniques to reduce those costs, but 
those sort of things are not usable in a ROM environment and are much more 
appropriate for a language like Python.

If you aren't using the interface as such (that is, with some form of 
dispatching), then it is simply a complication with no semantic meaning. 
There's no problem thinking about concepts as some sort of logical 
interface, but it is a distinction without meaning in that case. (By that 
logic, Ada 202x has interfaces for Image, indexing, dereferencing, literals, 
and streaming that can be applied to any tagged type.)

So either you are talking about a complication without value, or an 
extremely expensive implementation that doesn't meet the goals for a 
language like Ada. What's the point?

BTW, you have yet to show me any useful example that you can't reasonably do 
with a bounded vector (assuming that vector supports any discrete index 
type). For almost any possible language feature, there's always some example 
where it works better than the alternative using the basic features of the 
language. But that's not the question, the question is whether it is worth 
it in terms of language complexity, opportunity cost (time spent 
implementing feature X is time not spent on features A, B, and C), and 
usability (too many special case features make it harder to learn and use a 
language).

Slices fall on the wrong side of this boundary for me; the nonsense required 
to implement them seems reasonable at first but rapidly disappears as of the 
many other things that cannot be done in their presense. And they're mainly 
useful for strings, which are not arrays to begin with.

> You cannot do that with a single type and single dispatch.

Exactly my point. The implementation of multiple inheritance and multiple 
dispatch is simply too expensive for a language like Ada, and that's 
especially true in the case of basic building blocks like arrays/vectors.

The language you want is not feasible to implement IMHO. A language without 
a feasible implementation doesn't exist practically, and there's little 
sense in talking about it.

                                         Randy.