CVS difference for ai12s/ai12-0266-1.txt

Differences between 1.12 and version 1.13
Log of other versions for file ai12s/ai12-0266-1.txt

--- ai12s/ai12-0266-1.txt	2019/01/13 06:27:25	1.12
+++ ai12s/ai12-0266-1.txt	2019/01/22 01:23:37	1.13
@@ -1,4 +1,4 @@
-!standard 5.5.1(4/3)                                  19-01-12  AI12-0266-1/09
+!standard 5.5.1(4/3)                                  19-01-19  AI12-0266-1/10
 !standard 5.5.1(6/4)
 !standard 5.5.1(11/3)
 !standard 5.5.2(4/3)
@@ -54,14 +54,11 @@
 parallel with other chunks to collectively cover all the elements of the
 container.
 
-The starting cursor for each chunk of iteration can be obtained by calling the
-First_In_Chunk operation, passing in the chunk index of the split as a parameter
-to the call. The last cursor for each chunk of iteration can be obtained by
-calling the Last_In_Chunk operation, passing in the chunk index of the split
-as a parameter to the call. Similarly, the Next_In_Chunk and Previous_In_Chunk
-calls return the next or previous cursor in the chunk, and return a null
-cursor if the cursor is advanced past the last or before the first cursor
-of a chunk, respectively.
+The starting cursor for each chunk of iteration can be obtained by
+calling the overloading of First that takes the chunk index of the split
+as a parameter to the call. Similarly, calling Next
+with a chunk index returns the next cursor in the chunk, and returns a
+null cursor if the cursor is advanced past the last cursor of a chunk.
 
 In addition, the loop syntax is extended to allow the loops with iterator
 specifications to have the parallel keyword and to optionally specify a
@@ -80,341 +77,237 @@
      | parallel [(chunk_specification)]
        for iterator_specification
 
+Modify the start of 5.5(8.1/5):
+   If the reserved word parallel is present in {the iteration_scheme of} a
+   loop_statement (a parallel loop) ...
+
+   [Editor's note: the existing wording could be read as applying to any of the
+   contents of the sequence_of_statements, since they are "in" a loop_statement.
+   We surely don't want that, so we clarify the wording.]
+
+Modify 5.5(9.3/5):
+
+  Redundant[For details about the execution of a loop_statement with
+  the iteration_scheme [being for]{including an} iterator_specification,
+  see 5.5.2.]
+
+  [Editor's Note: This is necessary because the previous syntax change
+  added a second kind of iteration_scheme including an iterator_specification.]
+
 Add after 5.5.1(4/3):
 
-   type Parallel_Iterator is limited interface and Forward_Iterator
-      with Nonblocking => Cursor'Nonblocking and Has_Element'Nonblocking;
+   type Parallel_Iterator is limited interface and Forward_Iterator;
 
    subtype Chunk_Index is Positive;
 
    function Is_Split (Object : Parallel_Iterator)
-      return Boolean is abstract
-      with Nonblocking => Parallel_Iterator'Nonblocking;
+      return Boolean is abstract;
 
    procedure Split_Into_Chunks (Object     : in out Parallel_Iterator;
                                 Max_Chunks : Chunk_Index) is abstract
-      with Nonblocking => Parallel_Iterator'Nonblocking,
-           Pre'Class   => not Object.Is_Split or else raise Program_Error,
+      with Pre'Class   => not Object.Is_Split or else raise Program_Error,
            Post'Class  => Object.Is_Split and then
               Object.Chunk_Count <= Max_Chunks;
 
    function Chunk_Count (Object : Parallel_Iterator) return Chunk_Index
       is abstract
-      with Nonblocking => Parallel_Iterator'Nonblocking,
-           Pre'Class   => Object.Is_Split or else raise Program_Error;
+      with Pre'Class   => Object.Is_Split or else raise Program_Error;
 
-   function First_In_Chunk (Object : Parallel_Iterator;
-                            Chunk  : Chunk_Index) return Cursor is abstract
-      with Nonblocking => Parallel_Iterator'Nonblocking,
-           Pre'Class   => (Object.Is_Split and then Chunk <= Object.Chunk_Count)
+   function First (Object : Parallel_Iterator;
+                   Chunk  : Chunk_Index) return Cursor is abstract
+      with Pre'Class   => (Object.Is_Split and then Chunk <= Object.Chunk_Count)
                            or else raise Program_Error;
 
-   function Next_In_Chunk (Object   : Parallel_Iterator;
-                           Position : Cursor;
-                           Chunk    : Chunk_Index) return Cursor is abstract
-      with Nonblocking => Parallel_Iterator'Nonblocking,
-           Pre'Class   => (Object.Is_Split and then Chunk <= Object.Chunk_Count)
-                           or else raise Program_Error;
-
-   overriding
-   function First Object : Parallel_Iterator) return Cursor is abstract
-      with Nonblocking => Parallel_Iterator'Nonblocking;
-
-   overriding
    function Next (Object   : Parallel_Iterator;
-                  Position : Cursor) return Cursor is abstract
-      with Nonblocking => Parallel_Iterator'Nonblocking;
-
-   [Editor's note: We need the above overridings to make these routines
-   Nonblocking, else they would allow blocking as inherited from their
-   ancestors.]
-
-   type Parallel_Reversible_Iterator is limited interface
-      and Parallel_Iterator and Reversible_Iterator
-      with Nonblocking => Parallel_Iterator'Nonblocking;
-
-   function Last_In_Chunk (Object : Parallel_Reversible_Iterator;
-                           Chunk  : Chunk_Index) return Cursor is abstract
-      with Nonblocking => Parallel_Reversible_Iterator'Nonblocking,
-           Pre'Class   => (Object.Is_Split and then Chunk <= Object.Chunk_Count)
+                  Position : Cursor;
+                  Chunk    : Chunk_Index) return Cursor is abstract
+      with Pre'Class   => (Object.Is_Split and then Chunk <= Object.Chunk_Count)
                            or else raise Program_Error;
-
-   function Previous_In_Chunk (Object   : Parallel_Reversible_Iterator;
-                               Position : Cursor;
-                               Chunk    : Chunk_Index) return Cursor is abstract
 
-      with Nonblocking => Parallel_Reversible_Iterator'Nonblocking,
-           Pre'Class   => (Object.Is_Split and then Chunk <= Object.Chunk_Count)
-                           or else raise Program_Error;
-
-   overriding
-   function Last (Object : Parallel_Reversible_Iterator) return Cursor is abstract
-      with Nonblocking => Parallel_Reversible_Iterator'Nonblocking;
-
-   overriding
-   function Previous (Object   : Parallel_Reversible_Iterator;
-                      Position : Cursor) return Cursor is abstract
-      with Nonblocking => Parallel_Reversible_Iterator'Nonblocking;
-
+   type Parallel_Reversible_Iterator is limited interface
+      and Parallel_Iterator and Reversible_Iterator;
 
 Modify 5.5.1(6/3):
 
-An iterator type is a type descended from the Forward_Iterator
-interface from some instance of Ada.Iterator_Interfaces. A reversible iterator
-type is a type descended from the Reversible_Iterator interface from some
-instance of Ada.Iterator_Interfaces. {A parallel iterator type is a type
-descended from the Parallel_Iterator interface from some instance of
-Ada.Iterator_Interfaces. A parallel reversible iterator type is a type descended
-from the Parallel_Reversible_Iterator interface from some instance of
-Ada.Iterator_Interfaces.} An iterator object is an object of an iterator type. A
-reversible iterator object is an object of a reversible iterator type. {A
-parallel iterator object is an object of a parallel iterator type. A parallel
-reversible iterator object is an object of a parallel reversible iterator type.}
-The formal subtype Cursor from the associated instance of
-Ada.Iterator_Interfaces is the iteration cursor subtype for the iterator type.
+  An iterator type is a type descended from the Forward_Iterator interface from
+  some instance of Ada.Iterator_Interfaces. A reversible iterator type is a type
+  descended from the Reversible_Iterator interface from some instance of
+  Ada.Iterator_Interfaces. {A parallel iterator type is a type descended from
+  the Parallel_Iterator interface from some instance of Ada.Iterator_Interfaces.
+  A type descended from the Parallel_Reversible_Iterator interface from some
+  instance of Ada.Iterator_Interfaces is both a parallel iterator type and a
+  reversible iterator type.} An iterator object is an object of an iterator
+  type. A reversible iterator object is an object of a reversible iterator type.
+  {A parallel iterator object is an object of a parallel iterator type.} The
+  formal subtype Cursor from the associated instance of Ada.Iterator_Interfaces
+  is the iteration cursor subtype for the iterator type.
 
 Modify 5.5.1(11/3):
+
+  An iterable container type is an indexable container type with specified
+  Default_Iterator and Iterator_Element aspects. A reversible iterable container
+  type is an iterable container type with the default iterator type being a
+  reversible iterator type. {A parallel iterable container type is an iterable
+  container type with the default iterator type being a parallel iterator type.}
+  An iterable container object is an object of an iterable container type. A
+  reversible iterable container object is an object of a reversible iterable
+  container type. {A parallel iterable container object is an object of a
+  parallel iterable container type.}
 
-An iterable container type is an indexable container type with specified
-Default_Iterator and Iterator_Element aspects. A reversible iterable container
-type is an iterable container type with the default iterator type being a
-reversible iterator type. {A parallel iterable container type is an iterable
-container type with the default iterator type being a parallel iterator type.
-A parallel reversible iterable container type is a reversible iterable container
-type with the default iterator type being a parallel reversible iterator type.}
-An iterable container object is an object of an iterable container type. A
-reversible iterable container object is an object of a reversible iterable
-container type. {A parallel iterable container object is an object of a parallel
-iterable container type. A parallel reversible iterable container object is an
-object of a parallel reversible iterable container type.}
+Add after 5.5.2(2.1/5) (still as part of Syntax):
 
+  If an iterator_specification is for a parallel construct, the reserved word
+  reverse shall not appear in the iterator_specification.
+
 Modify 5.5.2(4/3):
 
-If the reserved word reverse appears, the iterator_specification is a reverse
-iterator{.}[;] {If the reserved word parallel appears, the
-iterator_specification is a parallel iterator;} otherwise it is a forward
-iterator. In a reverse generalized iterator, the iterator_name shall be of a
-reversible iterator type. {In a parallel generalized iterator, the iterator_name
-shall be of a parallel iterator type or a parallel reversible iterator type.} In
-a reverse container element iterator, the default iterator type for the type of
-the iterable_name shall be a reversible iterator type. {In a parallel container
-element iterator, the default iterator type for the type of the iterable_name
-shall be of a parallel iterator type or a parallel reversible iterator type.}
-
-Modify AARM 5.5.2(8.a/5):
-
-Ramification: The loop parameter of a generalized iterator has the
-same accessibility as the loop statement. This means that the loop parameter
-object{s} {are}[is] finalized when the loop statement is left. ([It]{They} also
-may be finalized as part of assigning a new value to the loop parameter.) For
-array component iterators, the loop parameter directly denotes an
-element of the array and has the accessibility of the associated array.
-For container element iterators, the loop parameter denotes the result
-of [the]{an} indexing function call (in the case of a constant indexing) or a
-generalized reference thereof (in the case of a variable indexing). Roughly
-speaking, the loop parameter has the accessibility level of a single
-iteration of the loop. More precisely, the function result (or the generalized
-reference thereof) is considered to be renamed in the declarative part of a
-notional block statement which immediately encloses the loop's
-sequence_of_statements; the accessibility of the loop parameter is that
-of the block statement.
+  If the reserved word reverse appears, the iterator_specification is a reverse
+  iterator{.}[;] {If the iterator_specification is for a parallel construct, the
+  iterator_specification is a parallel iterator;} otherwise it is a forward
+  iterator. {Forward and reverse iterators are collectively called /sequential/
+  iterators.} In a reverse generalized iterator, the iterator_name shall be of a
+  reversible iterator type. {In a parallel generalized iterator, the
+  iterator_name shall be of a parallel iterator type.} In a reverse container
+  element iterator, the default iterator type for the type of the iterable_name
+  shall be a reversible iterator type. {In a parallel container element
+  iterator, the default iterator type for the type of the iterable_name shall be
+  of a parallel iterator type.}
 
 Modify 5.5.2(10/3):
 
-For a generalized iterator {without the reserved word parallel},
-the loop parameter is created, the iterator_name is evaluated, and the denoted
-iterator object becomes the loop iterator. In a forward generalized iterator,
-the operation First of the iterator type is called on the loop iterator, to
-produce the initial value for the loop parameter. If the result of calling
-Has_Element on the initial value is False, then the execution of the loop_statement
-is complete. Otherwise, the sequence_of_statements is executed and then
-the Next operation of the iterator type is called with the loop iterator
-and the current value of the loop parameter to produce the next value to
-be assigned to the loop parameter. This repeats until the result of calling
-Has_Element on the loop parameter is False, or the loop is left as a
-consequence of a transfer of control. For a reverse generalized iterator
-{without the reserved word parallel},
-the operations Last and Previous are called rather than First and Next.
+  For a {sequential} generalized iterator, the loop parameter is created, the
+  iterator_name is evaluated, and the denoted iterator object becomes the loop
+  iterator. In a forward generalized iterator, the operation First of the
+  iterator type is called on the loop iterator, to produce the initial value for
+  the loop parameter. If the result of calling Has_Element on the initial value
+  is False, then the execution of the loop_statement is complete. Otherwise, the
+  sequence_of_statements is executed and then the Next operation of the iterator
+  type is called with the loop iterator and the current value of the loop
+  parameter to produce the next value to be assigned to the loop parameter. This
+  repeats until the result of calling Has_Element on the loop parameter is
+  False, or the loop is left as a consequence of a transfer of control. For a
+  reverse generalized iterator, the operations Last and Previous are called
+  rather than First and Next.
 
 
 Add after 5.5.2(10/3):
 
-The evaluation of a parallel generalized iterator first evaluates the
-chunk_specification, if any, and then the operation Split_Into_Chunks of
-the iterator type is called, with the Max_Chunks parameter specified
-as the upper bound for the number of loop parameter objects (and the number
-of logical threads of control) to be associated with the iterator. The
-corresponding actual parameter for Max_Chunks is determined by the
-chunk_specification, if present, otherwise the value is implementation defined.
-The number of chunks and loop parameters for the loop is determined by
-calling the Chunk_Count operation of the iterator. Each chunk has its own
-logical thread of control with its own copy of the loop parameter.
-
-     AARM To Be Honest: This wording does not describe when the loop parameter
-     object(s) are created. That creation has no side-effects (other than
-     possibly raising Storage_Error, but anything can do that), so we
-     simplified the wording by leaving it out. Each object has to be created
-     before any iteration that depends on it starts, but we do not (for
-     instance) require that the objects are all created at once at the start
-     of the loop.
-
-If a chunk_specification with a discrete_subtype_definition is present,
-then the logical thread of control associated with a given chunk has its
-own copy of the chunk parameter initialized with a distinct value from
-the discrete subtype defined by the discrete_subtype_definition.
-
-In a forward parallel generalized iterator, the operation First_In_Chunk
-of the iterator type is called on the loop iterator with the corresponding
-chunk parameter to produce the initial value for the loop parameter.
-If the result of calling Has_Element on the initial value is
-False, then the execution of the loop_statement is complete. Otherwise, the
-sequence_of_statements is executed and then the Next_In_Chunk operation of
-the iterator type is called with the loop iterator, the current value of
-the loop parameter, and the corresponding chunk parameter to produce the
-next value to be assigned to the loop parameter. This repeats
-until the result of calling Has_Element on the loop parameter is False, or
-the loop is left as a consequence of a transfer of control. For a reverse
-generalized iterator, the operations Last_In_Chunk and Previous_In_Chunk
-are called rather than First_In_Chunk and Next_In_Chunk.
-
-AARM Note
-
-The Max_Chunks parameter of the Split_Into_Chunks procedure is an upper
-bound for the number of chunks to be associated with a loop. A container
-implementation may opt for a lower value for the number of chunks if a
-more optimal split can be determined. For instance, a tree based container
-might create the split based on the number of branches at the top levels of the
-tree.
-
-Modify AARM 5.5.2(10.a/4):
-
-Ramification: The loop parameter of a generalized iterator [is a]{denotes}
-variable{s} of which the user only has a constant view. It follows the normal
-rules for a variable of its nominal subtype. In particular, if the nominal
-subtype is indefinite, the variable is constrained by its initial value.
-Similarly, if the nominal subtype is class-wide, the variable (like all
-variables) has the tag of the initial value. Constraint_Error may be raised by a
-subsequent iteration if Next [or]{,} Previous{, Next_In_Chunk, or
-Previous_In_Chunk} return an object with a different tag or constraint.
+  For a parallel generalized iterator, the chunk_specification, if any, of the
+  associated parallel construct, is first elaborated, to determine the maximum
+  number of chunks (see 5.5), and then the operation Split_Into_Chunks of the
+  iterator type is called, with the determined maximum passed as the Max_Chunks
+  parameter, specifying the upper bound for the number of loop parameter objects
+  (and the number of logical threads of control) to be associated with the
+  iterator. In the absence of a chunk_specification, the maximum number of
+  chunks is determined in an implementation defined manner.
+
+  Upon return from Split_Into_Chunks, the actual number of chunks for
+  the loop is determined by calling the Chunk_Count operation of the
+  iterator, at which point one logical thread of control is initiated
+  for each chunk, with an associated chunk index in the range from one
+  to the actual number of chunks. Within each logical thread of control,
+  a loop parameter is created. If a chunk_specification with a
+  discrete_subtype_definition is present in the associated parallel
+  construct, then a chunk parameter is created, and initialized with a
+  value from the discrete subtype defined by the
+  discrete_subtype_definition, so that the order of the chosen chunk
+  parameter values correspond to the order of the chunk indices
+  associated with the logical threads of control. The operation First
+  of the iterator type having a Chunk parameter is called on the loop
+  iterator, with Chunk initialized from the corresponding chunk index,
+  to produce the initial value for the loop parameter. If the result of
+  calling Has_Element on this initial value is False, then the execution
+  of the logical thread of control is complete. Otherwise, the
+  sequence_of_statements is executed and then the Next operation of the
+  iterator type having a Chunk parameter is called, with the loop
+  iterator, the current value of the loop parameter, and the
+  corresponding chunk index, to produce the next value to be assigned to
+  the loop parameter. This repeats until the result of calling
+  Has_Element on the loop parameter is False, or the associated parallel
+  construct is left as a consequence of a transfer of control. In the
+  absence of a transfer of control, the associated parallel construct of
+  a parallel generalized iterator is complete when all of its logical
+  threads of control are complete.
+
+    AARM Discussion: The Max_Chunks parameter of the Split_Into_Chunks procedure
+    is an upper bound for the number of chunks to be associated with a loop. A
+    container implementation may opt for a lower value for the number of chunks
+    if a more optimal split can be determined. For instance, a tree based
+    container might create the split based on the number of branches at the top
+    levels of the tree.
 
 Modify 5.5.2(11/3):
 
-[For]{The evaluation of} an array component iterator {first evaluates the
-chunk_specification, if any}, {and then} the iterable_name is evaluated and
-the denoted array object becomes the array for the loop. If the array for the
-loop is a null array, then the execution of the loop_statement is complete.
-Otherwise, the sequence_of_statements is executed with the loop parameter
-denoting each component of the array for the loop{. If the iterator is not a
-parallel array component iterator, the loop is iterated} using a canonical order
-of components, which is last dimension varying fastest (unless the array has
-convention Fortran, in which case it is first dimension varying fastest). For a
-forward array component iterator, the iteration starts with the component whose
-index values are each the first in their index range, and continues in the
-canonical order. For a reverse array component iterator, the iteration starts
-with the component whose index values are each the last in their index range,
-and continues in the reverse of the canonical order. {For a parallel array
-component iterator, the order of iteration is arbitrary.} The loop iteration
-proceeds until the sequence_of_statements has been executed for each component
-of the array for the loop, or until the loop is left as a consequence of a
-transfer of control. If the loop is a parallel loop, each chunk has its own
-logical thread of control with its own copy of the loop parameter; otherwise (a
-/sequential loop/), a single logical thread of control performs the loop, and
-there is a single copy of the loop parameter. Each logical thread of control
-handles a distinct chunk of the components of the array for the loop such that
-all components are covered with no overlaps. Within each logical thread of
-control, the values are assigned to the loop parameter in increasing index order
-unless the reserved word reverse is present, in which case the values are
-assigned in decreasing order.
-
-AARM To Be Honest: This wording does not describe when the loop parameter
-object(s) are created. That creation has no side-effects (other than
-possibly raising Storage_Error, but anything can do that), so we
-simplified the wording by leaving it out. Each object has to be created
-before any iteration that depends on it starts, but we do not (for
-instance) require that the objects are all created at once at the start
-of the loop.
-
-If a chunk_specification with a discrete_subtype_definition is present,
-then the logical thread of control associated with a given chunk has its
-own copy of the chunk parameter initialized with a distinct value from
-the discrete subtype defined by the discrete_subtype_definition. The
-values of the chunk parameters are assigned such that they increase with
-increasing values of the component index associated with the corresponding
-loop parameters.
+  For an array component iterator, the chunk_specification of the associated
+  parallel construct, if any, is first elaborated to determine
+  the maximum number of chunks (see 5.5), and then} the iterable_name is
+  evaluated and the denoted array object becomes the /array for the loop/. If
+  the array for the loop is a null array, then the execution of the
+  loop_statement is complete. Otherwise, the sequence_of_statements is executed
+  with the loop parameter denoting each component of the array for the loop,
+  using a canonical order of components, which is last dimension varying fastest
+  (unless the array has convention Fortran, in which case it is first dimension
+  varying fastest). For a forward array component iterator, the iteration starts
+  with the component whose index values are each the first in their index range,
+  and continues in the canonical order. For a reverse array component iterator,
+  the iteration starts with the component whose index values are each the last
+  in their index range, and continues in the reverse of the canonical order.
+  {For a parallel array component iterator, the iteration is broken up into
+  contiguous chunks of the canonical order, such that all components are covered
+  with no overlaps; each chunk has its own logical thread of control with its
+  own loop parameter and iteration within each chunk is in the canonical order.
+  The number of chunks is implementation defined, but is limited in the presence
+  of a chunk_specification to the determined maximum.} The loop iteration
+  proceeds until the sequence_of_statements has been executed for each component
+  of the array for the loop, or until the loop is left as a consequence of a
+  transfer of control.{
+
+  If a chunk_specification with a discrete_subtype_definition is present
+  in the associated parallel construct, then the logical thread of
+  control associated with a given chunk has a chunk parameter
+  initialized with a distinct value from the discrete subtype defined by
+  the discrete_subtype_definition. The values of the chunk parameters
+  are assigned such that they increase in the canonical order of the
+  starting array components for the chunks.}
 
 Modify 5.5.2(12/3):
 
-[For]{The evaluation of} a container element iterator {first evaluates the
-chunk_specification, if any}, {and then} the iterable_name is evaluated and
-the denoted iterable container object becomes the iterable container object
-for the loop. The default iterator function for the type of the iterable
-container object for the loop is called on the iterable container object
-and the result is the loop iterator. [An object] {Objects} of the default
-cursor subtype [is]{are} created (the loop cursor{s}).
-
-Modify 5.5.2(13/3): [into two paragraphs]
-
-For a forward container element iterator {without the reserved word parallel},
-the operation First of the iterator type is called on the loop iterator,
-to produce the initial value for the loop cursor. If the result of calling
-Has_Element on the initial value is False, then the execution of the
-loop_statement is complete. Otherwise, the sequence_of_statements is executed
-with the loop parameter denoting an indexing (see 4.1.6) into the iterable container
-object for the loop, with the only parameter to the indexing being the
-current value of the loop cursor; then the Next operation of the iterator
-type is called with the loop iterator and [the] loop cursor to produce the
-next value to be assigned to the loop cursor. This repeats until the result
-of calling Has_Element on the loop cursor is False, or until the loop is
-left as a consequence of a transfer of control. For a reverse container
-element iterator {without the reserved word parallel}, the operations Last
-and Previous are called rather than First and Next.{
-
-The evaluation of a parallel container element iterator first evaluates the
-chunk_specification, if any, and then the operation Split_Into_Chunks of
-the iterator type is called, with the Max_Chunks parameter specified
-as the upper bound for the number of loop parameter objects (and the number
-of logical threads of control) to be associated with the iterator. The
-corresponding actual parameter for Max_Chunks is determined by the
-chunk_specification, if present, otherwise the value is implementation defined.
-The number of chunks and loop parameters for the loop is determined by
-calling the Chunk_Count operation of the iterator. Each chunk has its own
-logical thread of control with its own copy of the loop parameter.
-
-     AARM To Be Honest: This wording does not describe when the loop parameter
-     object(s) are created. That creation has no side-effects (other than
-     possibly raising Storage_Error, but anything can do that), so we
-     simplified the wording by leaving it out. Each object has to be created
-     before any iteration that depends on it starts, but we do not (for
-     instance) require that the objects are all created at once at the start
-     of the loop.
-
-If a chunk_specification with a discrete_subtype_definition is present,
-then the logical thread of control associated with a given chunk has its
-own copy of the chunk parameter initialized with a distinct value from
-the discrete subtype defined by the discrete_subtype_definition.
-
-In a forward parallel container element iterator, the operation First_In_Chunk
-of the iterator type is called on the loop iterator with the corresponding
-chunk parameter to produce the initial value for the loop parameter.
-If the result of calling Has_Element on the initial value is
-False, then the execution of the loop_statement is complete. Otherwise, the
-sequence_of_statements is executed and then the Next_In_Chunk operation of
-the iterator type is called with the loop iterator, the current value of the
-loop parameter, and the corresponding chunk parameter to produce the next
-value to be assigned to the loop parameter. This repeats until the result
-of calling Has_Element on the loop parameter is False, or the loop is left
-as a consequence of a transfer of control. For a reverse
-parallel container element iterator, the operations Last_In_Chunk and
-Previous_In_Chunk are called rather than First_In_Chunk and Next_In_Chunk.
+  For a container element iterator, the chunk_specification of the associated
+  parallel construct, if any, is first elaborated (to determine the maximum
+  number of chunks -- see 5.5), and then} the iterable_name is evaluated and the
+  denoted iterable container object becomes the /iterable container object for
+  the loop/. The default iterator function for the type of the iterable
+  container object for the loop is called on the iterable container object and
+  the result is the /loop iterator/. {For a sequential container element
+  iterator, an}[An] object of the default cursor subtype is created (the /loop
+  cursor/).{ For a parallel container element iterator, each chunk of iterations
+  will have its own loop cursor, again of the default cursor subtype.}
+
+
+Replace 5.5.2(13/3) with the following:
+
+  A container element iterator then proceeds as described above for a
+  generalized iterator, except that each reference to a loop parameter
+  is replaced by a reference to the corresponding loop cursor. For a
+  container element iterator, the loop parameter for each iteration
+  instead denotes an indexing (see 4.1.6) into the iterable container
+  object for the loop, with the only parameter to the indexing being the
+  value of the loop cursor for the given iteration. If the loop
+  parameter is a constant (see above), then the indexing uses the
+  default constant indexing function for the type of the iterable
+  container object for the loop; otherwise it uses the default variable
+  indexing function.
 
 Modify 5.5.2(15/3):
 
 -- Array component iterator example:
-{parallel}
-for Element of Board loop  -- See 3.6.1.
-   Element := Element * 2.0; -- Double each element of Board, a two-dimensional array.
-end loop;
+  {parallel}
+  for Element of Board loop  -- See 3.6.1.
+     Element := Element * 2.0;
+        -- Double each element of Board, a two-dimensional array.
+  end loop;
 
+-----
 
 Modify A.18.2(74.1/3):
 
@@ -428,41 +321,44 @@
 
 Modify A.18.2(230.1/3):
 
-function Iterate (Container : in Vector)
-   return Vector_Iterator_Interfaces.{Parallel_}Reversible_Iterator'Class;
+  function Iterate (Container : in Vector)
+     return Vector_Iterator_Interfaces.{Parallel_}Reversible_Iterator'Class;
 
 Modify A.18.2(230.2/3):
 
-Iterate returns a {parallel} reversible iterator object (see 5.5.1) that will
-generate a value for a loop parameter (see 5.5.2) designating each node in
-Container, starting with the first node and moving the cursor as per the Next
-function when used as a forward iterator, and starting with the last node and
-moving the cursor as per the Previous function when used as a reverse iterator
-{, and starting with all nodes simultaneously when used as a parallel
-iterator}. Tampering with the cursors of Container is prohibited while the
-iterator object exists (in particular, in the sequence_of_statements of the
-loop_statement whose iterator_specification denotes this object). The iterator
-object needs finalization.
+  Iterate returns a {parallel and} reversible iterator object (see
+  5.5.1) that will generate a value for a loop parameter (see 5.5.2)
+  designating each node in Container, starting with the first node and
+  moving the cursor as per the Next function when used as a forward
+  iterator, and starting with the last node and moving the cursor as per
+  the Previous function when used as a reverse iterator {, and starting
+  with all nodes concurrently when used as a parallel iterator}.
+  Tampering with the cursors of Container is prohibited while the
+  iterator object exists (in particular, in the sequence_of_statements
+  of the loop_statement whose iterator_specification denotes this
+  object). The iterator object needs finalization.
 
 Modify A.18.2(230.3/3):
 
-function Iterate (Container : in Vector; Start : in Cursor)
-   return Vector_Iterator_Interfaces.{Parallel_}Reversible_Iterator'Class;
+  function Iterate (Container : in Vector; Start : in Cursor)
+     return Vector_Iterator_Interfaces.{Parallel_}Reversible_Iterator'Class;
 
 Modify A.18.2(230.4/3):
 
-If Start is not No_Element and does not designate an item in Container, then
-Program_Error is propagated. If Start is No_Element, then Constraint_Error is
-propagated. Otherwise, Iterate returns a {parallel }reversible iterator object
-(see 5.5.1) that will generate a value for a loop parameter (see 5.5.2)
-designating each node in Container, starting with the node designated by Start
-and moving the cursor as per the Next function when used as a forward iterator,
-or moving the cursor as per the Previous function when used as a reverse
-iterator {, or all nodes simultaneously when used as a parallel iterator}.
-Tampering with the cursors of Container is prohibited while
-the iterator object exists (in particular, in the sequence_of_statements of the
-loop_statement whose iterator_specification denotes this object). The iterator
-object needs finalization.
+  If Start is not No_Element and does not designate an item in
+  Container, then Program_Error is propagated. If Start is No_Element,
+  then Constraint_Error is propagated. Otherwise, Iterate returns a
+  {parallel and }reversible iterator object (see 5.5.1) that will
+  generate a value for a loop parameter (see 5.5.2) designating each
+  node in Container, starting with the node designated by Start and
+  moving the cursor as per the Next function when used as a forward
+  iterator, or moving the cursor as per the Previous function when used
+  as a reverse iterator {, or all nodes concurrently when used as a
+  parallel iterator}. Tampering with the cursors of Container is
+  prohibited while the iterator object exists (in particular, in the
+  sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.3(46.1/3):
 
@@ -481,16 +377,17 @@
 
 Modify A.18.3(144.2/3):
 
-Iterate returns a {parallel }reversible iterator object (see 5.5.1) that will
-generate a value for a loop parameter (see 5.5.2) designating each node in
-Container, starting with the first node and moving the cursor as per the Next
-function when used as a forward iterator, and starting with the last node and
-moving the cursor as per the Previous function when used as a reverse iterator
-{, and starting with all nodes simultaneously when used as a
-parallel iterator}. Tampering with the cursors of Container is prohibited while
-the iterator object exists (in particular, in the sequence_of_statements of the
-loop_statement whose iterator_specification denotes this object). The iterator
-object needs finalization.
+  Iterate returns a {parallel and }reversible iterator object (see
+  5.5.1) that will generate a value for a loop parameter (see 5.5.2)
+  designating each node in Container, starting with the first node and
+  moving the cursor as per the Next function when used as a forward
+  iterator, and starting with the last node and moving the cursor as per
+  the Previous function when used as a reverse iterator {, and starting
+  with all nodes concurrently when used as a parallel iterator}.
+  Tampering with the cursors of Container is prohibited while the
+  iterator object exists (in particular, in the sequence_of_statements
+  of the loop_statement whose iterator_specification denotes this
+  object). The iterator object needs finalization.
 
 Modify A.18.3(144.3/3):
 
@@ -499,18 +396,20 @@
 
 Modify A.18.3(144.4/3):
 
-If Start is not No_Element and does not designate an item in Container, then
-Program_Error is propagated. If Start is No_Element, then Constraint_Error is
-propagated. Otherwise, Iterate returns a {parallel} reversible iterator object
-(see 5.5.1) that will generate a value for a loop parameter (see
-5.5.2) designating each node in Container, starting with the node designated by
-Start and moving the cursor as per the Next function when used as a forward
-iterator, or moving the cursor as per the Previous function when used as a
-reverse iterator {or all nodes simultaneously used as a parallel iterator}.
-Tampering with the cursors of Container is prohibited while the iterator
-object exists (in particular, in the sequence_of_statements of the
-loop_statement whose iterator_specification
-denotes this object). The iterator object needs finalization.
+  If Start is not No_Element and does not designate an item in
+  Container, then Program_Error is propagated. If Start is No_Element,
+  then Constraint_Error is propagated. Otherwise, Iterate returns a
+  {parallel and} reversible iterator object (see 5.5.1) that will
+  generate a value for a loop parameter (see 5.5.2) designating each
+  node in Container, starting with the node designated by Start and
+  moving the cursor as per the Next function when used as a forward
+  iterator, or moving the cursor as per the Previous function when used
+  as a reverse iterator {or all nodes concurrently used as a parallel
+  iterator}. Tampering with the cursors of Container is prohibited while
+  the iterator object exists (in particular, in the
+  sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.5(37.1/3):
 
@@ -524,15 +423,16 @@
 
 Modify A.18.5(61.2/3):
 
-Iterate returns a[n] {parallel} iterator object (see 5.5.1) that will generate
-a value for a loop parameter (see 5.5.2) designating each node in
-Container, starting with the first node and moving the cursor according to the
-successor relation {when used as a forward iterator, and starting with all nodes
-simultaneously when used as a parallel iterator}. Tampering with the
-cursors of Container is prohibited while the iterator object exists (in
-particular, in the sequence_of_statements of the loop_statement whose
-iterator_specification denotes this object). The iterator object needs
-finalization.
+  Iterate returns a[n] {parallel} iterator object (see 5.5.1) that will
+  generate a value for a loop parameter (see 5.5.2) designating each
+  node in Container, starting with the first node and moving the cursor
+  according to the successor relation {when used as a forward iterator,
+  and starting with all nodes concurrently when used as a parallel
+  iterator}. Tampering with the cursors of Container is prohibited while
+  the iterator object exists (in particular, in the
+  sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.6(51.1/3):
 
@@ -551,16 +451,18 @@
 
 Modify A.18.6(94.2/3):
 
-Iterate returns a {parallel} reversible iterator object (see 5.5.1) that will
-generate a value{s} for a loop parameter (see 5.5.2) designating each
-node in Container, starting with the first node and moving the cursor according
-to the successor relation when used as a forward iterator, and starting with the
-last node and moving the cursor according to the predecessor relation when used
-as a reverse iterator {, and starting with all nodes simultaneously when
-used as a parallel iterator}. Tampering with the cursors of Container
-is prohibited while the iterator object exists (in particular, in the
-sequence_of_statements of the loop_statement whose iterator_specification
-denotes this object). The iterator object needs finalization.
+  Iterate returns a {parallel and} reversible iterator object (see
+  5.5.1) that will generate a value{s} for a loop parameter (see 5.5.2)
+  designating each node in Container, starting with the first node and
+  moving the cursor according to the successor relation when used as a
+  forward iterator, and starting with the last node and moving the
+  cursor according to the predecessor relation when used as a reverse
+  iterator {, and starting with all nodes concurrently when used as a
+  parallel iterator}. Tampering with the cursors of Container is
+  prohibited while the iterator object exists (in particular, in the
+  sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.6(94.3/3):
 
@@ -569,19 +471,20 @@
 
 Modify A.18.6(94.4/3):
 
-If Start is not No_Element and does not designate an item in Container, then
-Program_Error is propagated. If Start is No_Element, then Constraint_Error is
-propagated. Otherwise, Iterate returns a {parallel} reversible iterator object
-(see 5.5.1) that will generate a value for a loop parameter (see
-5.5.2) designating each node in Container, starting with the node designated by
-Start and moving the cursor according to the successor relation when used as a
-forward iterator, or moving the cursor according to the predecessor relation
-when used as a reverse iterator {, or all nodes simultaneously when used
-as a parallel iterator}. Tampering with the cursors of Container is
-prohibited while the iterator object exists (in
-particular, in the sequence_of_statements of the loop_statement whose
-iterator_specification denotes this object). The iterator object needs
-finalization.
+  If Start is not No_Element and does not designate an item in
+  Container, then Program_Error is propagated. If Start is No_Element,
+  then Constraint_Error is propagated. Otherwise, Iterate returns a
+  {parallel and} reversible iterator object (see 5.5.1) that will
+  generate a value for a loop parameter (see 5.5.2) designating each
+  node in Container, starting with the node designated by Start and
+  moving the cursor according to the successor relation when used as a
+  forward iterator, or moving the cursor according to the predecessor
+  relation when used as a reverse iterator{, or all nodes concurrently
+  when used as a parallel iterator}. Tampering with the cursors of
+  Container is prohibited while the iterator object exists (in
+  particular, in the sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.8(49.1/3):
 
@@ -595,15 +498,16 @@
 
 Modify A.18.8(85.2/3):
 
-Iterate returns a[n] {parallel} iterator object (see 5.5.1) that will generate
-a value for a loop parameter (see 5.5.2) designating each element in
-Container, starting with the first element and moving the cursor according to
-the successor relation {when used as a forward iterator, and starting with all
-nodes simultaneously when used as a parallel iterator.} Tampering
-with the cursors of Container is prohibited while the iterator object exists (in
-particular, in the sequence_of_statements of the loop_statement whose
-iterator_specification denotes this object). The iterator object needs
-finalization.
+  Iterate returns a[n] {parallel} iterator object (see 5.5.1) that will
+  generate a value for a loop parameter (see 5.5.2) designating each
+  element in Container, starting with the first element and moving the
+  cursor according to the successor relation {when used as a forward
+  iterator, and starting with all nodes concurrently when used as a
+  parallel iterator.} Tampering with the cursors of Container is
+  prohibited while the iterator object exists (in particular, in the
+  sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.9(61.1/3):
 
@@ -622,17 +526,18 @@
 
 Modify A.18.9(113.2/3):
 
-Iterate returns a {parallel} reversible iterator object (see 5.5.1) that will
-generate a value for a loop parameter (see 5.5.2) designating each
-element in Container, starting with the first element and moving the cursor
-according to the successor relation when used as a forward iterator, and
-starting with the last element and moving the cursor according to the
-predecessor relation when used as a reverse iterator {, and starting with all
-nodes simultaneously when used as a parallel iterator}. Tampering
-with the cursors of Container is prohibited while the iterator object exists (in
-particular, in the sequence_of_statements of the loop_statement whose
-iterator_specification denotes this object). The iterator object needs
-finalization.
+  Iterate returns a {parallel and} reversible iterator object (see 5.5.1)
+  that will generate a value for a loop parameter (see 5.5.2)
+  designating each element in Container, starting with the first element
+  and moving the cursor according to the successor relation when used as
+  a forward iterator, and starting with the last element and moving the
+  cursor according to the predecessor relation when used as a reverse
+  iterator {, and starting with all nodes concurrently when used as a
+  parallel iterator}. Tampering with the cursors of Container is
+  prohibited while the iterator object exists (in particular, in the
+  sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.9(113.3/3):
 
@@ -641,19 +546,20 @@
 
 Modify A.18.9(113.4/3):
 
-If Start is not No_Element and does not designate an item in Container, then
-Program_Error is propagated. If Start is No_Element, then Constraint_Error is
-propagated. Otherwise, Iterate returns a {parallel} reversible iterator object
-(see 5.5.1) that will generate a value for a loop parameter (see
-5.5.2) designating each element in Container, starting with the element
-designated by Start and moving the cursor according to the successor relation
-when used as a forward iterator, or moving the cursor according to the
-predecessor relation when used as a reverse iterator {, or all nodes
-simultaneously when used as a parallel
-iterator}. Tampering with the cursors of Container is prohibited while the
-iterator object exists (in particular, in the sequence_of_statements of the
-loop_statement whose iterator_specification denotes this object). The iterator
-object needs finalization.
+  If Start is not No_Element and does not designate an item in
+  Container, then Program_Error is propagated. If Start is No_Element,
+  then Constraint_Error is propagated. Otherwise, Iterate returns a
+  {parallel and} reversible iterator object (see 5.5.1) that will generate a
+  value for a loop parameter (see 5.5.2) designating each element in
+  Container, starting with the element designated by Start and moving
+  the cursor according to the successor relation when used as a forward
+  iterator, or moving the cursor according to the predecessor relation
+  when used as a reverse iterator {, or all nodes concurrently when used
+  as a parallel iterator}. Tampering with the cursors of Container is
+  prohibited while the iterator object exists (in particular, in the
+  sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.10(44/3):
 
@@ -672,15 +578,16 @@
 
 Modify A.18.10(157/4)
 
-Iterate returns a[n] {parallel} iterator object (see 5.5.1) that will generate
-a value for a loop parameter (see 5.5.2) designating each element node
-in Container, starting from with the root node and proceeding in a depth-first
-order {when used as a forward_iterator, and starting with all nodes
-simultaneously when used as a parallel iterator}. Tampering with the
-cursors of Container is prohibited while the iterator object exists (in
-particular, in the sequence_of_statements of the loop_statement whose
-iterator_specification denotes this object). The iterator object needs
-finalization.
+  Iterate returns a[n] {parallel} iterator object (see 5.5.1) that will
+  generate a value for a loop parameter (see 5.5.2) designating each
+  element node in Container, starting from with the root node and
+  proceeding in a depth-first order {when used as a forward_iterator,
+  and starting with all nodes concurrently when used as a parallel
+  iterator}. Tampering with the cursors of Container is prohibited while
+  the iterator object exists (in particular, in the
+  sequence_of_statements of the loop_statement whose
+  iterator_specification denotes this object). The iterator object needs
+  finalization.
 
 Modify A.18.10(158/3):
 
@@ -689,24 +596,25 @@
 
 Modify A.18.10(159/3):
 
-If Position equals No_Element, then Constraint_Error is propagated. Otherwise,
-Iterate_Subtree returns a[n] {parallel} iterator object (see 5.5.1) that will
-generate a value for a loop parameter (see 5.5.2) designating each
-element in the subtree rooted by the node designated by Position, starting from
-with the node designated by Position and proceeding in a depth-first order {when
-used as a forward iterator, or all nodes simultaneously when used as a
-parallel iterator}. If Position
-equals No_Element, then Constraint_Error is propagated. Tampering with the
-cursors of the container that contains the node designated by Position is
-prohibited while the iterator object exists (in particular, in the
-sequence_of_statements of the loop_statement whose iterator_specification
-denotes this object). The iterator object needs finalization.
+  If Position equals No_Element, then Constraint_Error is propagated.
+  Otherwise, Iterate_Subtree returns a[n] {parallel} iterator object
+  (see 5.5.1) that will generate a value for a loop parameter (see
+  5.5.2) designating each element in the subtree rooted by the node
+  designated by Position, starting from with the node designated by
+  Position and proceeding in a depth-first order {when used as a forward
+  iterator, or all nodes concurrently when used as a parallel iterator}.
+  If Position equals No_Element, then Constraint_Error is propagated.
+  Tampering with the cursors of the container that contains the node
+  designated by Position is prohibited while the iterator object exists
+  (in particular, in the sequence_of_statements of the loop_statement
+  whose iterator_specification denotes this object). The iterator object
+  needs finalization.
 
 
 !discussion
 
 Containers such as vectors are obvious candidates for parallelization, since it
-is easy to conceptually think of a vector as a being splittable into a number of
+is easy to conceptually think of a vector as being splittable into a number of
 smaller vectors, and then applying a divide and conquer approach to the vector
 subsets. However, even a sequentially accessed container such as a linked list
 can be iterated in parallel if cursors for each parallel executor can be
@@ -716,17 +624,17 @@
 significantly greater than the amount of time needed to iterate through the
 container.
 
-The container writer has the ability to implement the container to define
-an optimal number of loop parameters to be setup by the Split_Into_Chunks call,
-so long as the number of splits is not greater than the value of the
-Max_Chunks parameter.
-
-In AI12-0119 we admitted the possibility of chunks, but the model was
-always one logical thread of control per iteration. Here (and in AI12-0251-1)
-we make chunks explicit in the model, with one logical thread of control per chunk.
-This is important to make it clear that all of the iterations associated
-with a chunk are part of a single logical thread of control, so there is no
-data race between the iterations of a single chunk.
+The container writer has the ability to implement the container to define an
+optimal number of loop parameters to be setup by the Split_Into_Chunks call, so
+long as the number of splits is not greater than the value of the Max_Chunks
+parameter.
+
+In AI12-0119 we admitted the possibility of chunks, but the model was always one
+logical thread of control per iteration. Here (and in AI12-0251-1) we make
+chunks explicit in the model, with one logical thread of control per chunk. This
+is important to make it clear that all of the iterations associated with a chunk
+are part of a single logical thread of control, so there is no data race between
+the iterations of a single chunk.
 
 This proposal allows the container implementer a fair amount of flexibility in
 deciding how to implement the cursor array stored in the iterator object. In
@@ -742,8 +650,8 @@
 iterator types of the containers are controlled types, so finalization of the
 iterator objects is already part of the iteration model.
 
-It would have been nice to specify a post condition for the Split_Into_Chunks
-call something like;
+It would have been nice to specify a post condition for the
+Split_Into_Chunks call something like;
 
   with Post => (for all I in 1 .. Object.Split_Count =>
                  Has_Element (Object.Get_Cursor (I)))
@@ -752,13 +660,14 @@
 a post condition in this package because the Cursor formal type is an
 untagged incomplete type.
 
-Similarly, it would have been nice to write a Post condition for First_In_Chunk
-where calling Has_Element on the result would return true, however this is also
-not allowed for the same reason.
-
-We could consider adding these as Pre and Post contracts in the derived types
-in each of the containers, but the iterator types are not declared in the
-public part of the package, so it seems to be not worthwhile to do so.
+Similarly, it would have been nice to write a Post condition for First
+with a chunk index where calling Has_Element on the result would return
+true, however this is also not allowed for the same reason.
+
+We could consider adding these as Pre and Post contracts in the derived
+types in each of the containers, but the iterator types are not declared
+in the public part of the package, so it seems to be not worthwhile to
+do so.
 
 
 !ASIS
@@ -2236,53 +2145,53 @@
 Sent: Sunday, January 13, 2019  12:25 AM
 
 > Here is an update to AI12-0266-1, Parallel Container Iteration
-> 
-> This is mostly to address the comments that Randy sent out 
+>
+> This is mostly to address the comments that Randy sent out
 > against my previous version.
 
 Thanks for doing this.
 
 One thing that jumped out at me:
 
-The corresponding actual parameter for Max_Chunks is determined by the 
-chunk_specification, if present, otherwise the value is implementation 
+The corresponding actual parameter for Max_Chunks is determined by the
+chunk_specification, if present, otherwise the value is implementation
 defined.
 
-We certainly want this to be true, but you never said *how* Max_Chunks is 
-determined by the chunk_specification. I think you're trying to piggyback on 
-5.5(8.1/5), but it might be useful to say that somewhere. BTW, 5.5 says that 
-the chunk_specification is elaboration, because a loop_parameter_specification 
-is a declaration. And so is an iterator_specification, note that 5.5.2(9/3) 
-talks about "elaboration", not "evaluation". (Angels on a pin, I know.) Also, 
-each of these paragraphs starts with "For a <something>", and we might as well 
+We certainly want this to be true, but you never said *how* Max_Chunks is
+determined by the chunk_specification. I think you're trying to piggyback on
+5.5(8.1/5), but it might be useful to say that somewhere. BTW, 5.5 says that
+the chunk_specification is elaboration, because a loop_parameter_specification
+is a declaration. And so is an iterator_specification, note that 5.5.2(9/3)
+talks about "elaboration", not "evaluation". (Angels on a pin, I know.) Also,
+each of these paragraphs starts with "For a <something>", and we might as well
 stick with that.
 
 So I'd leave the sentence above alone, and change the first one:
 
-{For a}[The evaluation of a parallel] generalized iterator {with the reserved 
+{For a}[The evaluation of a parallel] generalized iterator {with the reserved
 word parallel} first {elaborates}[evaluates] the chunk_specification (see 5.5),
 if any, and then the operation Split_Into_Chunks ...
 
 Except that this is still missing the other parts (creating the loop parameter
-and evaluating the iterator_name} of setting up the loop. Since you separated 
+and evaluating the iterator_name} of setting up the loop. Since you separated
 the wording into sequential and parallel descriptions (which I agree with), we
 have to repeat all of that stuff.
 
 So, something like:
 
-For a generalized iterator with the reserved word parallel, the 
-chunk_specification (see 5.5), if any, is first elaborated (see 5.5), then 
-the iterator_name is evaluated, and the denoted iterator object becomes the 
+For a generalized iterator with the reserved word parallel, the
+chunk_specification (see 5.5), if any, is first elaborated (see 5.5), then
+the iterator_name is evaluated, and the denoted iterator object becomes the
 loop iterator. Next, the operation Split_Into_Chunks ...
 
-But we still have to describe where the loop parameters are created. Unlike 
-the discrete case, that *can* have side-effects, so your copy of the AARM 
+But we still have to describe where the loop parameters are created. Unlike
+the discrete case, that *can* have side-effects, so your copy of the AARM
 note is wrong. We can't get away with ignoring that here.
 
-And I don't have a good idea for addressing this. So I'm punting it back to 
+And I don't have a good idea for addressing this. So I'm punting it back to
 you. :-)
 
-Note that similar issues occur later for the other kinds of iterators, where 
+Note that similar issues occur later for the other kinds of iterators, where
 you inserted "evaluation" rather than "elaboration".
 
 ****************************************************************

Questions? Ask the ACAA Technical Agent