std::ranges::less(3)

NAME
std::ranges::less - std::ranges::less

Synopsis
   Defined in header <functional>
   struct less; (since C++20)
   Function object for performing comparisons. Deduces the parameter types of the
   function call operator from the arguments (but not the return type).

Member functions
   operator() checks if the first argument is less than the second
              (public member function) std::ranges::less::operator()
   template< class T, class U >
   constexpr bool operator()( T&& t, U&& u ) const;
   Given the expression std::forward<T>(t) < std::forward<U>(u) as expr:
     * If expr results in a call to built-in operator< comparing pointers, given the
       composite pointer type of t and u as P:
     * If the converted t precedes the converted u (both are of type P) in the
       implementation-defined strict total order over pointers, returns true, otherwise
       returns false.
     * If the conversion sequence from T to P or the conversion sequence from U to P is
       not equality-preserving, the behavior is undefined.
     * Otherwise:
     * Returns the result of expr.
     * If std::totally_ordered_with<T, U> is not modeled, the behavior is undefined.
   This overload participates in overload resolution only if
   std::totally_ordered_with<T, U> is satisfied.
   If there exists an expression expr1 of type T and an expression expr2 of U, such
   that the comparison results of expr1 and expr2 violate strict total ordering (rules
   are defined below), the behavior is undefined.
   The comparison results of expr1 and expr2 follow strict total ordering only if
   exactly one of the following expressions is true:
     * std::ranges::less{}(expr1, expr2)
     * std::ranges::less{}(expr2, expr1)
     * std::ranges::equal_to{}(expr1, expr2)

Notes
   Unlike std::less, std::ranges::less requires all six comparison operators <, <=, >,
   >=, == and != to be valid (via the totally_ordered_with constraint).

Example
    This section is incomplete
    Reason: no example
   Defect reports
   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.
      DR Applied to Behavior as published Correct behavior
   LWG 3530 C++20 syntactic checks were relaxed only semantic requirements are
                       while comparing pointers relaxed

See also
   less function object implementing x < y
        (class template)

Category:
     * Todo no example