Rationale for Ada 2012

John Barnes
Contents   Index   References   Search   Previous   Next 

3.7 Qualified expressions

We conclude this discussion of expressions by considering some points regarding names and primarys.
In Ada 2005 we have
name ::=
    direct_name | explicit_dereference | indexed_component
  | slice | selected_component | attribute_reference
  | type_conversion | function_call | character_literal
primary ::=
    numeric_literal | null | string_literal | aggregate | name
  | qualified_expression | allocator | (expression)]
And in Ada 2012 we have
name ::=
    direct_name | explicit_dereference | indexed_component
  | slice | selected_component | attribute_reference
  | type_conversion | function_call | character_literal
  | qualified_expression | generalized_reference
  | generalized_indexing
primary ::=
    numeric_literal | null | string_literal | aggregate | name
  | allocator | (expression)]
  | (conditional_expression) | (quantified_expression)
The important thing to observe here is that qualified_expression has moved from being a form of primary to being a name.
We also note the addition of conditional_expression and quantified_expression (both in parentheses) as forms of primary as discussed earlier in this chapter and the addition of generalized_reference and generalized_indexing as forms of name. These are used in the new forms of iterator briefly alluded to at the end of the discussion on quantified expressions and which will be discussed in Section 6.3.
Returning to qualified expressions, the main reason for allowing them as names is to avoid unnecessary conversions as mentioned in the Introduction (see 1.3.2).
A: T;        -- object of type T
type Art is array (1 .. 10) of T;        -- array of type T
function F(X: Integer) return Art;
A function call can be used as a prefix and so a call returning an array can be indexed as in
A := F(3)(7);
which assigns to A the value of the 7th component of the array returned by the call of F.
Now suppose that F is overloaded so that F(3) is ambiguous. The normal solution to such ambiguities is to use qualification and write Art'(F(3)) as in
A := Art'(F(3))(7);    -- illegal in Ada 2005
but this is illegal in Ada 2005 because a qualified expression is not a name and so cannot be used as a prefix. What one has to do in Ada 2005 is either copy the wretched array (really naughty) or add a type conversion (a type conversion is a name) thus
A := Art(Art'(F(3)))(7);
This is really gruesome; but in Ada 2012, qualification is permitted as a name so we can simply write
A := Art'(F(3))(7);    -- OK in Ada 2012
Although a qualified expression is now classed as a name rather than a primary, a qualified variable is not considered to be a variable. As a consequence, a qualified variable cannot be used as the destination of an assignment or as an actual parameter corresponding to an out or in out parameter. This would have added complexity for no useful purpose. Ambiguity generally involves calls on overloaded functions, and the result of a function call is always a constant, so ambiguous names of variables are unlikely!
Other uses might involve strings which can also give rise to ambiguities. For example
("a string")'Length
is ambiguous (it could be a String or Wide_String).
But now we can write
String'("a string")'Length
which was not permitted in Ada 2005.

Contents   Index   References   Search   Previous   Next 
© 2011, 2012, 2013 John Barnes Informatics.
Sponsored in part by:
The Ada Resource Association:


and   Ada-Europe: