Re: Ada2012 : In praise of 'for ... of ... loop'...

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

On 07.06.12 02:19, Randy Brukardt wrote:
> "Georg Bauhaus"<rm.dash-bauhaus@futureapps.de>  wrote in message
> news:4fc69e72$0$6633$9b4e6d93@newsspool2.arcor-online.net...
> ...
>> In Ada 2012, there is an Iterate function in the 2012 Vectors that
>> takes a parameter Start : Cursor, but not a corresponding Finish : Cursor.
>
> You don't really need one, because you can use "exit" in the for loop in
> order to stop the iteration early.

In the case of generic algorithms, the situation is a bit reversed,
since "it can stop the iteration early", where "it" is the generic
algorithm that has the for loop in its body. Using Ada 2005, the
generic algorithm need knowledge of a Cursor type and an Element
function:

       loop
          exit when Cur = One_After;
          Result := Binop (Result, Element (Cur));
          Cur := Next (Cur);
       end loop;

Using Ada 2012, the following looks nice, but might not (currently?)
be possible, because Cursor (detailed below) is an incomplete tagged
formal type of Iterator_Interfaces, and can't be used here:

       for Cur in Span loop     -- Span : Forward_Iterator'Class
	 exit when Cur = One_After;
          Result := Binop (Result, Element (Cur));
       end loop;

It also felt a little odd to have to pass both a Forward_Iterator
and a Cursor so that the loop could be stopped early. If the following
attempt is a possible solution at all.

The full algorithm below is adapted for use with Forward_Iterator
as you suggested (such as the one returned by function Vectors.Iterate)
IIUC. GNAT complains about invalid use and premature use of
Iteration.Cursor, more so in case I write "use type Iteration.Cursor".
(I have omitted testing for One_After "<=" Start.)

with Ada.Iterator_Interfaces;

generic
    type Element_Type is private;
    with package Iteration is new Ada.Iterator_Interfaces (<>);
    with function Element (Position : Iteration.Cursor) return Element_Type;
package Iterations_2012 is

    generic
       Zero      : in Element_Type;
       with function Binop (Left, Right : in Element_Type) return Element_Type;
    function Reduce_2012
      (Span	: in Iteration.Forward_Iterator'Class;
       One_After	: in Iteration.Cursor)  --!
    return Element_Type;
    --  Apply Binop to the sequence of elements in Span, excluding every
    --  element starting at One_After

end Iterations_2012;


package body Iterations_2012 is

    function Reduce_2012
      (Span	: Iteration.Forward_Iterator'Class;
       One_After	: Iteration.Cursor) return Element_Type
    is
       Result : Element_Type;
       use Iteration;  -- use type Iteration.Cursor; --!
    begin
       Result := Zero;
       for Cur in Span loop
	 exit when Cur = One_After;  --!
          Result := Binop (Result, Element (Cur));
       end loop;
       return Result;
    end Reduce_2012;

end Iterations_2012;


A typical scenario I have in mind is divide and conquer: there are tasks
that will perform some algorithm on (sub)sequences of elements from just
any container.