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

The equality operators = (equals) and /= (not equals) are predefined for
nonlimited types. The other relational_operators are the ordering
operators < (less than), <= (less than or equal), > (greater than), and
>= (greater than or equal). The ordering operators are predefined for
scalar types, and for discrete array types, that is, onedimensional
array types whose components are of a discrete type.

A membership test, using in or not in, determines whether or not a value
belongs to a given subtype or range, or has a tag that identifies a type
that is covered by a given type. Membership tests are allowed for all
types.
Name Resolution Rules

The tested type of a membership test is the type of the range or the
type determined by the subtype_mark. If the tested type is tagged, then
the simple_expression shall resolve to be of a type that covers or is
covered by the tested type; if untagged, the expected type for the
simple_expression is the tested type.
Legality Rules

For a membership test, if the simple_expression is of a tagged
classwide type, then the tested type shall be (visibly) tagged.
Static Semantics

The result type of a membership test is the predefined type Boolean.

The equality operators are predefined for every specific type T that is
not limited, and not an anonymous access type, with the following
specifications:

function "=" (Left, Right : T) return Boolean
function "/="(Left, Right : T) return Boolean

The ordering operators are predefined for every specific scalar type T,
and for every discrete array type T, with the following specifications:

function "<" (Left, Right : T) return Boolean
function "<="(Left, Right : T) return Boolean
function ">" (Left, Right : T) return Boolean
function ">="(Left, Right : T) return Boolean
Dynamic Semantics

For discrete types, the predefined relational operators are defined in
terms of corresponding mathematical operations on the position numbers
of the values of the operands.

For real types, the predefined relational operators are defined in terms
of the corresponding mathematical operations on the values of the
operands, subject to the accuracy of the type.

Two accesstoobject values are equal if they designate the same object,
or if both are equal to the null value of the access type.

Two accesstosubprogram values are equal if they are the result of the
same evaluation of an Access attribute_reference, or if both are equal
to the null value of the access type. Two accesstosubprogram values
are unequal if they designate different subprograms. It is unspecified
whether two access values that designate the same subprogram but are the
result of distinct evaluations of Access attribute_references are equal
or unequal.

For a type extension, predefined equality is defined in terms of the
primitive (possibly userdefined) equals operator of the parent type and
of any tagged components of the extension part, and predefined equality
for any other components not inherited from the parent type.

For a private type, if its full type is tagged, predefined equality is
defined in terms of the primitive equals operator of the full type; if
the full type is untagged, predefined equality for the private type is
that of its full type.

For other composite types, the predefined equality operators (and
certain other predefined operations on composite types  See section 4.5.1 Logical Operators and Shortcircuit Control Forms,
and See section 4.6 Type Conversions.) are defined in terms of the corresponding operation on
matching components, defined as follows:

For two composite objects or values of the same nonarray type, matching
components are those that correspond to the same component_declaration
or discriminant_specification;

For two onedimensional arrays of the same type, matching components are
those (if any) whose index values match in the following sense: the
lower bounds of the index ranges are defined to match, and the
successors of matching indices are defined to match;

For two multidimensional arrays of the same type, matching components
are those whose index values match in successive index positions.

The analogous definitions apply if the types of the two objects or
values are convertible, rather than being the same.

Given the above definition of matching components, the result of the
predefined equals operator for composite types (other than for those
composite types covered earlier) is defined as follows:

If there are no components, the result is defined to be True;

If there are unmatched components, the result is defined to be False;

Otherwise, the result is defined in terms of the primitive equals
operator for any matching tagged components, and the predefined equals
for any matching untagged components.

The predefined "/=" operator gives the complementary result to the
predefined "=" operator.

For a discrete array type, the predefined ordering operators correspond
to lexicographic order using the predefined order relation of the
component type: A null array is lexicographically less than any array
having at least one component. In the case of nonnull arrays, the left
operand is lexicographically less than the right operand if the first
component of the left operand is less than that of the right; otherwise
the left operand is lexicographically less than the right operand only
if their first components are equal and the tail of the left operand is
lexicographically less than that of the right (the tail consists of the
remaining components beyond the first and can be null).

For the evaluation of a membership test, the simple_expression and the
range (if any) are evaluated in an arbitrary order.

A membership test using in yields the result True if:

The tested type is scalar, and the value of the simple_expression
belongs to the given range, or the range of the named subtype; or

The tested type is not scalar, and the value of the simple_ expression
satisfies any constraints of the named subtype, and, if the type of the
simple_expression is classwide, the value has a tag that identifies a
type covered by the tested type.

Otherwise the test yields the result False.

A membership test using not in gives the complementary result to the
corresponding membership test using in.
NOTES

(13) No exception is ever raised by a membership test, by a predefined
ordering operator, or by a predefined equality operator for an
elementary type, but an exception can be raised by the evaluation of the
operands. A predefined equality operator for a composite type can only
raise an exception if the type has a tagged part whose primitive equals
operator propagates an exception.

(14) If a composite type has components that depend on discriminants,
two values of this type have matching components if and only if their
discriminants are equal. Two nonnull arrays have matching components if
and only if the length of each dimension is the same for both.
Examples

Examples of expressions involving relational operators and membership
tests:

X /= Y

"" < "A" and "A" < "Aa"  True
"Aa" < "B" and "A" < "A "  True

My_Car = null
 true if My_Car has been set to null See section 3.10.1 Incomplete Type Declarations
My_Car = Your_Car
 true if we both share the same car
My_Car.all = Your_Car.all
 true if the two cars are identical

N not in 1 .. 10
 range membership test
Today in Mon .. Fri
 range membership test
Today in Weekday
 subtype membership test See section 3.5.1 Enumeration Types
Archive in Disk_Unit
 subtype membership test, See section 3.8.1 Variant Parts and Discrete Choices
Tree.all in Addition'Class
 class membership test See section 3.9.1 Type Extensions
Go to the first, previous, next, last section, table of contents.