Re: Imitation is the sincerest form of flattery

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

Hyman Rosen wrote:

> Dmitry A. Kazakov wrote:
>> First of all, there is no contract. I want the compiler be
>  > aware that it is going to be an array and check if it is.
> 
> You have proxy classes that deal with all of this stuff.
> Everything is typechecked.

The type is checked, not the class. It is same as in case of the formal 
parameters generics. That discussion we already had.

>> Secondly to make A[i]=X working you have to use a reference. Now, let I a
>> have a packed bit array. What would be a reference to a bit? You would
>> need to build a fat pointer class to fix this. The array has to represent
>> an image in the video buffer. It has to be damn FAST. And where are
>> multidimensional arrays in C++? And where are slices? Well, for them we
>> need another class, etc. And what if A is a hash table, sparse array. It
>> would be monstrous. And I want it on the stack!
> 
> It's not monstrous at all. First of all, as an Ada programmer,
> you should not be complaining about having to write extra lines
> of code to do what you want, as long as its all nice and readable.

I would complain. I do not like extra lines, especially any helper classes. 
Array is an old well known concept, which requires no baroque kinks.

> Second of all, just because you need classes to handle all of this
> doesn't prevent things from being on the stack, or from being fast.

Right, but not in C++, which is unable to handle unconstrained objects on 
the stack.

> Third of all, there is plenty of existing code to do this sort of
> thing, in Boost and elsewhere.
> 
> Remembering some of our previous threads, I would caution you that
> the proper way to implement all of this will eschew inheritance and
> use templates heavily. If you try to do this using OO, then yes,
> your code will be miserably slow.

But as you said it should not be slow.

>> IMO. The idea of treating
>>     A[i]=X;
>> as
>>     Assign (Index (A, i), X);
>> is a wrong one.
> 
> Why? In particular, this technique is used very often in C++,
> especially with expression templates. One has Index(A,i) just
> return a proxy class which holds A and i, and implements the
> Assign to take such a class. Inline expansion does the rest,
> usually resulting in code that looks like an open-coded version.

Even if this could work as expected, then why the compiler cannot do all 
that to me? But it does not work. If you want to pass an element as an 
in-out parameter (remember Ada has them), your nasty proxy class will show 
itself. Then to reconcile this with LSP you will have to make it derived 
from the type of the element. Ooch ... And this was supposed to be ADT, not 
OO!

--
Regards,
Dmitry A. Kazakov
www.dmitry-kazakov.de