Ada Conformity Assessment Authority      Home Conformity Assessment   Test Suite ARGAda Standard
 
Annotated Ada Reference ManualLegal Information
Contents   Index   References   Search   Previous   Next 

4.5.8 Quantified Expressions

0.1/4
  {AI12-0158-1} Quantified expressions provide a way to write universally and existentially quantified predicates over containers and arrays.

Syntax

1/3
{AI05-0176-1} quantified_expression ::= for quantifier loop_parameter_specification => predicate
  | for quantifier iterator_specification => predicate
2/3
quantifier ::= all | some
3/3
predicate ::= boolean_expression
4/3
{AI05-0176-1} Wherever the Syntax Rules allow an expression, a quantified_expression may be used in place of the expression, so long as it is immediately surrounded by parentheses.
4.a/3
Discussion: The syntactic category quantified_expression appears only as a primary that is parenthesized. The above rule allows it to additionally be used in other contexts where it would be directly surrounded by parentheses. This is the same rule that is used for conditional_expressions; see 4.5.7 for a detailed discussion of the meaning and effects of this rule. 

Name Resolution Rules

5/3
{AI05-0176-1} The expected type of a quantified_expression is any Boolean type. The predicate in a quantified_expression is expected to be of the same type. 

Dynamic Semantics

6/4
{AI05-0176-1} {AI12-0158-1} 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 the values 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).
7/3
{AI05-0176-1} The value of the quantified_expression is determined as follows:
8/4
{AI12-0158-1} If the quantifier is all, the expression is False True if the evaluation of any the predicate yields False; evaluation of the quantified_expression stops at that point. Otherwise (every predicate has been evaluated and yielded True), the expression is True True for each value of the loop parameter. It is False otherwise. Evaluation of the quantified_expression stops when all values of the domain have been examined, or when the predicate yields False for a given value. Any exception raised by evaluation of the predicate is propagated.
8.a/3
Ramification: The expression is True if the domain contains no values. 
9/4
{AI12-0158-1} If the quantifier is some, the expression is True if the evaluation of any the predicate yields True; evaluation of the quantified_expression stops at that point. Otherwise (every predicate has been evaluated and yielded False), the expression is False for some value of the loop parameter. It is False otherwise. Evaluation of the quantified_expression stops when all values of the domain have been examined, or when the predicate yields True for a given value. Any exception raised by evaluation of the predicate is propagated.
9.a/3
Ramification: The expression is False if the domain contains no values. 

Examples

10/3
 {AI05-0176-1} The postcondition for a sorting routine on an array A with an index subtype T can be written:
11/3
Post => (A'Length < 2 or else
   (for all I in A'First .. T'Pred(A'Last) => A (I) <= A (T'Succ (I))))
12/3
 {AI05-0176-1} The assertion that a positive number is composite (as opposed to prime) can be written:
13/3
pragma Assert (for some X in 2 .. N / 2 => N mod X = 0);

Extensions to Ada 2005

13.a/3
{AI05-0176-1} Quantified expressions are new. 

Wording Changes from Ada 2012

13.b/4
{AI12-0158-1} Corrigendum: Revised the wording to make it clear that the semantics is short-circuited, and what the result is when there are no values for the loop parameter. 

Contents   Index   References   Search   Previous   Next 
Ada-Europe Ada 2005 and 2012 Editions sponsored in part by Ada-Europe