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

Differences between 1.1 and version 1.2
Log of other versions for file ai12s/ai12-0158-1.txt

```--- ai12s/ai12-0158-1.txt	2015/03/24 04:04:41	1.1
+++ ai12s/ai12-0158-1.txt	2015/03/27 00:05:52	1.2
@@ -1,7 +1,10 @@
-!standard 4.5.8(1/3)                                   15-03-23  AI05-0158-1/01
+!standard 4.5.8(1/3)                                   15-03-26  AI05-0158-1/02
+!standard 4.5.8(6/3)
!standard 4.5.8(8/3)
!standard 4.5.8(9/3)
!class binding interpretation 15-03-23
+!status Corrigendum 2015 15-03-26
+!status ARG Approved 8-0-2  15-03-26
!status work item 15-03-23
!priority Low
@@ -30,25 +33,19 @@

Add before 4.5.8(1/3): [before "Syntax", that is as introductory text]

-Quantified expressions provide a convinient way to write universal and existential
-quantifiers over containers including arrays. They're useful in preconditions
-and postconditions even if you don't understand what the heck the above
-means. :-)
-
-[Editor's note: This is obviously a placeholder for some text to be written by
-someone with more knowledge of these operations than me. It seems valuable to
-summarize what these do, including he mathematical difference "for all" and
-"for some" so that people don't feel compelled to try to shoehorn that into
-the dynamic semantics.]
+Quantified expressions provide a way to write universally and existentially
+quantified predicates over containers and arrays.

-4.5.8(6-7/3) [not modified, provided for context]
+Replace 4.5.8(6/3) with:

For the evaluation of a quantified_expression, the loop_parameter_specification
or iterator_specification is first elaborated. The evaluation of a
-quantified_expression then evaluates the predicate for each value of the loop
-parameter. These values are examined in the order specified by the
-loop_parameter_specification (see 5.5) or iterator_specification (see 5.5.2).
+quantified_expression then evaluates the predicate for the values of the loop
+parameter in the order specified by the loop_parameter_specification (see 5.5)
+or iterator_specification (see 5.5.2).

+4.5.8(7/3) [not modified, provided for context]
+
The value of the quantified_expression is determined as follows:

Replace 4.5.8(8/3) with:
@@ -87,6 +84,30 @@
make them appear to be similar to some set operation. That sort of thing is
best done in the introduction, rather than trying to bend the dynamic semantics
to serve that purpose. We add an introductory paragraph to serve this purpose.
+
+!corrigendum 4.5.8(1/3)
+
+@dinsb
+@xcode<@fa<quantified_expression ::= >@ft<@b<for>>@fa< quantifier loop_parameter_specification =@> predicate
+   | >@ft<@b<for>>@fa< quantifier iterator_specification =@> predicate>>
+@dinst
+Quantified expressions provide a way to write universally and existentially
+quantified predicates over containers and arrays.
+
+!corrigendum 4.5.8(6/3)
+
+@drepl
+For the evaluation of a @fa<quantified_expression>, the @fa<loop_parameter_specification>
+or @fa<iterator_specification> is first elaborated. The evaluation of a
+@fa<quantified_expression> then evaluates the predicate for the values of the loop
+parameter in the order specified by the @fa<loop_parameter_specification>
+(see 5.5) or @fa<iterator_specification> (see 5.5.2).
+@dby
+For the evaluation of a @fa<quantified_expression>, the @fa<loop_parameter_specification>
+or @fa<iterator_specification> is first elaborated. The evaluation of a
+@fa<quantified_expression> then evaluates the predicate for each value of the
+loop parameter. These values are examined in the order specified by the
+@fa<loop_parameter_specification> (see 5.5) or @fa<iterator_specification> (see 5.5.2).

!corrigendum 4.5.8(8/3)

```

Questions? Ask the ACAA Technical Agent