Re: Vector of Vectors.

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

Robert A Duff schrieb:
> Georg Bauhaus <see.reply.to@maps.futureapps.de> writes:
> 
>> Robert A Duff wrote:
>>
>>> The loop body is usually self explanatory.  E.g:
>> I wish it were, yes. A loop body _should_ be
>> elf explanatory.  FWIW, I have not seen a loop
>> with just single statement in quite a while.
>> Hope things are in different shape elsewhere.
> 
> Not sure what you mean.  I'm saying that Ada's current support for
> iterators requires you to wrap the loop body in a named procedure.
> The fact that people don't normally wrap loop bodies in procedures
> (when using 'for' and 'while' loops) proves that doing so is a burden.

But the fact that people don't normally bother to wrap loop bodies in
procedures is not a prove that to do must be wrong, or that giving
a loop name might not in fact be preferrable.  Yes, it is work to
find a good name but OTOH, it is considered good style, in particular
in Ada culture, to Say What You Mean. AFAIK.

I agree that the example you have given might show
some silly formalism. But again, is this a typical
scenario warranting more anonymity in Ada?

Eiffel's new anonymous agents (access sub parameters with
partially bound arguments) have met some criticism, too, BTW.

Here is another example, one active and one passive
iteration.  Does the loop body deserve a captivating
title?  Then, maybe in the form of a named local procedure.


   function Active (Data: Vector; Threshold: Amount) return Amount is

      N: Positive;                      -- nth item
      Result: Amount;
      Item: Amount;

   begin
      Result := 0.0;
      N := 1;
      for Index in First_Index(Data) .. Last_Index(Data) loop
         Item := Element(Data, Index);
         if Item < Threshold then
            Result := ((N - 1) * Result + Item) / N;
            N := N + 1;
         else
            Skipped := Skipped + 1;
         end if;
      end loop;
      return Result;
   end Active;



   function Passive (Data: Vector; Threshold: Amount) return Amount is

      N: Positive;                      -- nth item
      Result: Amount;

      procedure Incremental_Average(Position: in Cursor) is
         Item: constant Amount := Element(Position);
      begin
         if Item < Threshold then
            Result := ((N - 1) * Result + Item) / N;
            N := N + 1;
         else
            Skipped := Skipped + 1;
         end if;
      end Incremental_Average;

   begin
      Result := 0.0;
      N := 1;
      Iterate(Data, Process => Incremental_Average'Access);
      return Result;
   end Passive;



In Active, the new syntax you have suggested will shorten
the loop body a bit, making Item's declaration in Active's
declarative part unneccesary.  But still, there will be a
few lines left, worth a comment, at least?  If so,
then why not write a named body?


Writing quick, anonymous, non-recursive lamdas is fun,
but there is inherent danger in making them a language
feature, I think.  The danger is that they are going to
be used like they are being used in Python, or
Perl:  spanning multiple lines, trying to be clever,
avoid finding a name, write them once, never understand
them again.

See also the proliferation of anonymous access  ;-)
(I recall Vdim Gunko (I think) saying that adding named 'class
pointers to the Qt4 (C++) binding is too much of a burdon...