Go to the first, previous, next, last section, table of contents.
Static Semantics

The binary adding operators + (addition) and  (subtraction) are
predefined for every specific numeric type T with their conventional
meaning. They have the following specifications:

function "+"(Left, Right : T) return T
function ""(Left, Right : T) return T

The concatenation operators & are predefined for every nonlimited,
onedimensional array type T with component type C. They have the
following specifications:

function "&"(Left : T; Right : T) return T
function "&"(Left : T; Right : C) return T
function "&"(Left : C; Right : T) return T
function "&"(Left : C; Right : C) return T
Dynamic Semantics

For the evaluation of a concatenation with result type T, if both
operands are of type T, the result of the concatenation is a
onedimensional array whose length is the sum of the lengths of its
operands, and whose components comprise the components of the left
operand followed by the components of the right operand. If the left
operand is a null array, the result of the concatenation is the right
operand. Otherwise, the lower bound of the result is determined as
follows:

If the ultimate ancestor of the array type was defined by a
constrained_array_definition, then the lower bound of the result is that
of the index subtype;

If the ultimate ancestor of the array type was defined by an
unconstrained_array_definition, then the lower bound of the result is
that of the left operand.

The upper bound is determined by the lower bound and the length. A check
is made that the upper bound of the result of the concatenation belongs
to the range of the index subtype, unless the result is a null array.
Constraint_Error is raised if this check fails.

If either operand is of the component type C, the result of the
concatenation is given by the above rules, using in place of such an
operand an array having this operand as its only component (converted to
the component subtype) and having the lower bound of the index subtype
of the array type as its lower bound.

The result of a concatenation is defined in terms of an assignment to an
anonymous object, as for any function call, See section 6.5 Return Statements.
NOTES

(15) As for all predefined operators on modular types, the binary adding
operators + and  on modular types include a final reduction modulo the
modulus if the result is outside the base range of the type.
Examples

Examples of expressions involving binary adding operators:

Z + 0.1
 Z has to be of a real type

"A" & "BCD"
 concatenation of two string literals
'A' & "BCD"
 concatenation of a character literal and a string literal
'A' & 'A'
 concatenation of two character literals
Go to the first, previous, next, last section, table of contents.