# Concept Subspace :: sus :: cmp :: Ord

template <class Lhs, class Rhs = Lhs>concept Ord

StrongOrd<Lhs, Rhs> || requires(const std::remove_reference_t<Lhs>& lhs,

const std::remove_reference_t<Rhs>& rhs) {

{ lhs <=> rhs } -> std::same_as<std::weak_ordering>;

}

Concept for types that form a total ordering (aka
`std::weak_ordering`

).

Types that satisfy `Ord`

can be sorted or compared and
always return a consistent result as all possible values are comparable.
Objects that compare as equivalent for ordering may still be different
internally and compare as different through `operator==`

. If unique identity
is required, use `StrongOrd`

. Otherwise, typically
use `Ord`

for constraining types that will be ordered.

# How can I implement Ord?

`Ord`

requires that the type has `operator<=>`

which
returns
`std::weak_ordering`

(or
`std::strong_ordering`

).
It will implicitly also be `Ord`

and
`PartialOrd`

as a result.

# Lexicographical comparison

Lexicographical comparison is an operation with the following properties:

- Two sequences are compared element by element.
- The first mismatching element defines which sequence is lexicographically less or greater than the other.
- If one sequence is a prefix of another, the shorter sequence is lexicographically less than the other.
- If two sequence have equivalent elements and are of the same length, then the sequences are lexicographically equal.
- An empty sequence is lexicographically less than any non-empty sequence.
- Two empty sequences are lexicographically equal.

# Ord and Eq interations

While `Ord`

can report equality, it does not imply that
the type satisfies `Eq`

, and a separate `operator==`

is
required for that concept. Unlike
`StrongOrd`

, it is not required that objects which
are ordered as equivalent also compare as equal with `operator==`

.

Generic code that requires a type to be `Ord`

should
take care to use `operator<=>`

and not `operator==`

unless also requiring
`Eq`

, in which case consider requiring
`StrongOrd`

in place of both
`Ord`

and `Eq`

.

# Determining Ord strictly

`Ord`

will be also satisfied if the types satisfy
`StrongOrd`

. To determine if a
`Ord`

is the strongest type of ordering between the
types, use `ExclusiveOrd`

.