The class tt(std::partial_ordering)hi(partial_ordering) is used when
implementing the spaceship operator for classes that support all comparison
operators (where one operand may be zero), that do not support
substitutability, and whose objects, using the spaceship operator itself, can
also be compared to any other type of object.

The class tt(partial_ordering) provides free functions for all comparison
operations (tt(==, !=, <, <=, >,) and tt(>=)) expecting tt(partial_ordering)
arguments (one argument may be 0). It also defines four static objects which
can be returned by the spaceship operator:
    itemization(
    itt(partial_ordering::less), returned when the lhs operand of the
        spaceship operator should be ordered before the rhs operand;
    itt(partial_ordering::equivalent), indicating equality: there is no
        ordering preference between the two operands of the spaceship operator;
    itt(partial_ordering::greater), returned when the lhs operand of the
        spaceship operator should be ordered after the rhs operand;
    itt(partial_ordering::unordered), returned when all comparison operators
        of a class implementing the spaceship operator should return tt(false)
        (so tt(==, !=, <, <=, >,) and tt(>=) all return tt(false)).
    )

As an example, consider road taxes. Trucks, cars, and motor cycles have to pay
road taxes, but there's no road tax for bicycles. For ordering road taxes a
class tt(RoadTax) may be used, defining the following spaceship operator
(assuming that all types of vehicles are derived from a class tt(Vehicle), and
that tt(Vehicle) has a (virtual) member tt(double roadTax()) returning the
amount of road tax that is due for the various types of vehicles; the amount
is negative if no road tax is required):
    verb(    partial_ordering RoadTax::operator<=>(Vehicle const &lhs, 
                                          Vehicle const &rhs)
    {
        return
          lhs.roadTax() < 0 or rhs.roadTax() < 0 ?
                                          partial_ordering::unordered :
          lhs.roadTax() < rhs.roadTax() ? partial_ordering::less      :
          lhs.roadTax() > rhs.roadTax() ? partial_ordering::greater   :
                                          partial_ordering::equivalent;
    })



