As suggested in a reply to my previous proposal, I drafted a proposal to introduce the std::is_uniqued() function.

Since it was developed from Arthur's idea, I would be very happy if you took part in the proposal.

I. Motivation

The std::is_uniqued() function can be used to check if a range of elements has no consecutive equal elements.

Even if there is already the std::adjacent_find() function, that can be used to get the same effect, the introduction of the function std::is_uniqued makes the check clearer, like std::contains() and std::is_sorted() do.

II. Impact on the standard

This proposal simply adds new standard functions into the algorithm header. It does not require any changes in core language. It has been implemented in standard C++.

III. Design decisions

template<
class ForwardIt >

constexpr bool is_uniqued( ForwardIt first,
ForwardIt last );

template<
class ForwardIt , class BinaryPredicate>

constexpr bool
is_uniqued( ForwardIt first, ForwardIt last, BinaryPredicate pred );

template<
class ExecutionPolicy, class ForwardIt >

bool is_uniqued(
ExecutionPolicy&& policy, ForwardIt first, ForwardIt last );

template<
class ExecutionPolicy, class ForwardIt, class BinaryPredicate>

bool
is_uniqued(ExecutionPolicy policy, ForwardIt first, ForwardIt last,
BinaryPredicate pred );

Checks if the elements in the range [first, last) are unique.

A sequence is uniqued with respect to a binary predicate pred if any iterator it pointing to the sequence and the consecutive ++it iterator pointing to an element in the sequence, pred(*it, *(++it)) evaluates to false.

1)
elements are compared using operator==. The behavior is undefined if it is not an equivalence relation.

2)
elements are compared using the given binary predicate pred. The behavior is undefined if it is not an equivalence relation.

3, 4) Same as (1, 2), but executed according to policy. These overloads do not partecipate in overload resolution unless std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> is true.

Preconditions:

ForwardIt must meet the requirements of LegacyForwardIterator.

At most std::distance(first, last).

Exceptions:

If execution of a function invoked as part of the algorithm throws an exception and ExecutionPolicy is one of the standard policies, std::terminate is called. For any other ExecutionPolicy, the behavior is implementation-defined.

If the algorithm fails to allocate memory, std::bad_alloc is thrown.

/*
Ranges */

template< std::forward_iterator I,
std::sentinel_for<I> S, class Proj =

std::identity,
std::indirect_equivalence_relation Proj>> Pred = ranges::equal_to
>

constexpr bool is_uniqued( I first, S last, Pred pred = {},
Proj proj = {} );

template< ranges::forward_range R,
class Proj =
std::identity,

std::indirect_equivalent_relation<std::projected<ranges::iterator_t<R>,
Proj>,

std::projected<ranges::iterator_t<R>, Proj>
Pred = ranges::equal_to>

constexpr
bool is_uniqued( R&& r, Pred pred = {}, Proj proj = {} );

1) elements are compared using the given binary predicate pred.

2) Same as (1), but uses r as the source range, as if using ranges::begin(r) as first and ranges::end(r) as last.

Complexity:

1) At most std::distance(first, last).

2) At most ranges::distance(r).