Re: Containers - nontrivial element access

["Alex R. Mosteo" <devnull@mailinator.com>]

Maciej Sobczak wrote:

> On 2 Pa , 01:52, "Alex R. Mosteo" <devn...@mailinator.com> wrote:
> 
>> I'm not sure the solution is clunky, unless you consider verbose=clunky.
> 
> The point is that in order to swap data, you need to pass the new
> value to the modifying procedure. Since there are no on-the-fly
> binders, this value has to be provided by additional variable, which
> exists outside of the procedure, which access is passed. This looks
> like a dodgy hack: I provide a procedure, which is not self-contained
> anyway, so I also sneak around the value.

Uh? I think Matthew's solution doesn't use anything extra?

Further example: imagine that containers had this subprogram:

procedure Operate 
  (This : in out Vector;
   I, J :        Index_Type;
   Op   : access not null procedure (L, R : in out Element_Type));

Now, this Operate procedure does Matthew's nested accessing in place and
calls the provided Op procedure. Swapping (or anything else) would be:

declare
   procedure Swap (L, R : in out Whatever) is
   -- You know the deal
begin
   My_Vector.Operate (X, Y, Swap'Access);
end;

Does it look good? This isn't in the containers, but you can provide it
yourself. Is what I thought of yesterday night, but I (mistakenly) thought
you were more concerned with verbosity so I didn't bothered to exemplify.

> 
> I have nothing against the procedure, even if it is longer (/= clunky)
> than what I can do in C++. I have, however, a *serious* problem with
> sneaking this value around.
> This *is* clunky.

Can you summarize it for me? Is Matthew's solution satisfactory? I've passed
a bit fast over the thread :)

> 
>> There are additional differences, if I'm not mistaken (my C++ is a bit
>> outdated). [] is, I think, unchecked (unlike .at()), so you could get a
>> violation with that code that shouldn't be possible in Ada.
> 
> You are half right. The standard does not require [] to be checked. It
> does not forbid it, either.
> 
> The point is not about [], actually, but about references. I might
> have written my example like this:
> 
> swap(people.at(x).salary, people.at(y).salary);
> 
> and then you would not have been able to nit-pick on the possible
> violation. :-)

Of course :). It was just something that came to me when reading your post
and just throw it in with the rest of the lot.

> 
> --
> Maciej Sobczak * www.msobczak.com * www.inspirel.com