# std::experimental::ranges::less

> C++ Atlas: `cppatlas.com/w/cpp/experimental/ranges/functional/less` | Source: https://en.cppreference.com/w/cpp/experimental/ranges/functional/less | Domain: Technical specifications

Function object for performing comparisons. The primary template invokes operator< on const lvalues of type T.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <experimental/ranges/functional>

template< class T = void >
    requires StrictTotallyOrdered<T> ||
             Same<T, void> ||
             /* < on two const T lvalues invokes a built-in operator comparing pointers */
struct less; // (ranges TS)

template<>
struct less<void>; // (ranges TS)
```

Function object for performing comparisons. The primary template invokes `operator<` on const lvalues of type `T`. The specialization `less<void>` deduces the parameter types of the function call operator from the arguments (but not the return type).

All specializations of `less` are `Semiregular`.

#### Member types

**Member type — Definition**

- `is_transparent` (member only of `less<void>` specialization): /* unspecified */

#### Member functions

- `operator()`: checks if the first argument is *less* than the second (public member function)

### std::experimental::ranges::less::operator()

```cpp
constexpr bool operator()(const T& x, const T& y) const; // (1) (member only of primary less<T> template)

template< class T, class U >
    requires StrictTotallyOrderedWith<T, U> ||
             /* std::declval<T>() < std::declval<U>() resolves to
                a built-in operator comparing pointers */
constexpr bool operator()(T&& t, U&& u) const; // (2) (member only of less<void> specialization)
```

1) Compares `x` and `y`. Equivalent to `return ranges::less<>{}(x, y);`.

2) Compares `t` and `u`. Equivalent to `return std::forward<T>(t) < std::forward<U>(u);`, except when that expression resolves to a call to a builtin `operator<` comparing pointers.

When a call to (1) or (2) would invoke a built-in operator comparing pointers of type `P`, the result is instead determined as follows:

- Returns `true` if the (possibly converted) value of the first argument precedes the (possibly converted) value of the second argument in the implementation-defined strict total ordering over all pointer values of type `P`. This strict total ordering is consistent with the partial order imposed by the builtin operators `<`, `>`, `<=`, and `>=`.
- Otherwise, returns `false`.

The behavior is undefined unless the conversion sequences from both `T` and `U` to `P` are equality-preserving (see below).

#### Equality preservation

An expression is *equality preserving* if it results in equal outputs given equal inputs.

- The inputs to an expression consist of its operands.
- The outputs of an expression consist of its result and all operands modified by the expression (if any).

Every expression required to be equality preserving is further required to be *stable*: two evaluations of such an expression with the same input objects must have equal outputs absent any explicit intervening modification of those input objects.

#### Notes

Unlike `std::less`, `ranges::less` requires all six comparison operators `<`, `<=`, `>`, `>=`, `==` and `!=` to be valid (via the `StrictTotallyOrdered` and `StrictTotallyOrderedWith` constraints).

#### Example

> Note: This section is incomplete Reason: no example

#### See also

- [`less`](https://en.cppreference.com/w/cpp/utility/functional/less): function object implementing `x < y` (class template)

---
Attribution: content from https://en.cppreference.com/w/cpp/experimental/ranges/functional/less (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.