[libc++][ranges] implement `std::ranges::unique{_copy}`

[huixie90]

Summary

implement std::ranges::unique and std::ranges::unique_copy

Several changes:

1. implement std::ranges::unique that delegates to std::unique

2. fix classic std::unique_copy does not work with output iterator that satisfies both InputIterator and OutputIterator requirements.

background: The classic implementation does tag dispatch on the iteartor_category of the output iterator and uses output_iterator_tag as a fallback. However, if the user passes an output iterator that satisfy both
InputIterator and OutputIterator requirement, the iteartor_category is likely to be input_iteartor_tag and input_iteartor_tag does not derive from output_iterator_tag. So the fallback case would not work.

See this example where msvc stl correctly implemented and libc++ errors out
https://godbolt.org/z/7shKshEPa

The fix to the classic algorithm is strictly following the wording

If InputIterator meets the Cpp17ForwardIterator requirements, then there are no additional requirements for T.

Having an overload that takes __reread_from_input_tag, which does auto prev = in; comp(*prev, *in)

Otherwise, if OutputIterator meets the Cpp17ForwardIterator requirements and its value type is the same as T, then T meets the Cpp17CopyAssignable (Table 33) requirements.

Having an overload that takes __reread_from_output_tag, which does comp(*out, *in)

Otherwise, T meets both the Cpp17CopyConstructible (Table 31) and Cpp17CopyAssignable requirements.

Having an overload that takes __read_from_tmp_value_tag, which does value_type tmp = *in; ++in; comp(tmp, *in)

3. implement std::ranges::unique_copy, which reuses the implementation above, but slightly different dispatching condition as ranges version has slightly different requires constraints.

Also I believe the std::ranges::unique_copy is incorrectly constrained. More specifically, the intent of the constraint (input_­iterator<O> && same_­as<iter_value_t<I>, iter_value_t<O>>) was to allow implementations to write comp(*in ,*out) (ignore std::invoke and projection for now). However, I and O having the same value_type is not enough to allow comp(*in ,*out), because that expression only uses the iter_reference_t of the I and O, instead of the iter_value_t. See discussion here
https://discord.com/channels/737189251069771789/737189251497721887/1000875764650094692

But anyway, I decided that in this patch, implement what exactly in the spec and bring up the issue in LWG later.

[huixie90]

fix CI

[huixie90]

refactor unique_copy

[huixie90]

implement unique_copy

[var-const]

LGTM, leaving the final approval to @ldionne.

libcxx/include/__algorithm/adjacent_find.h

49

Nit: move?

libcxx/include/__algorithm/unique.h

39

Nit: I'd move the increment back into its own line, otherwise there's a little too much going on on this line.

libcxx/include/__algorithm/unique_copy.h

82

Perhaps InputOrOutputIterator?

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/ranges_unique.pass.cpp

129

Optional: maybe check a single-element range for good measure?

libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp

89

Please also update test/std/algorithms/ranges_result_alias_declarations.compile.pass.cpp.

[huixie90]

addresss feedback

libcxx/include/__algorithm/unique_copy.h

82

Renamed to InputAndOutputIterator

[huixie90]

rebase

[huixie90]

• finalise ranges::remove_copy{_if}

[huixie90]

got patch number wrong

[ldionne]

Thanks a lot for the patch @huixie90! Since you're on vacation, @var-const can you please commandeer to finish this up? LGTM w/ comments applied.

libcxx/include/__algorithm/adjacent_find.h

28–35

How about this? It's equivalent, but I find it slightly easier to read.

Non-blocking if you disagree.

libcxx/include/__algorithm/ranges_unique_copy.h

125

FWIW this formatting is really hard to read for me, I assume it's produced by clang-format?

libcxx/include/__algorithm/unique_copy.h

38

I think we should call it __unique_copy instead for consistency with other algorithms (even though I understand we're passing an additional tag parameter).

47

Do we have a test for calling unique_copy with a value_type that is not copyable? IIUC that would be valid when the input range is at least a forward_iterator.

[huixie90]

address review feedback

[huixie90]

Also thanks to @Quuxplusone who contacted me and spotted that I missed an if constexpr in ranges::unique_copy and an unnecessary next call in adjacent_find

libcxx/include/__algorithm/adjacent_find.h

28–35

Yes your suggestion is easier to read

libcxx/include/__algorithm/ranges_unique_copy.h

125

yes it is done by clang-format. yes it is really hard to read. I will try manually formatting it.

libcxx/include/__algorithm/unique_copy.h

38

sure will rename. the direct reason I didn't use __unique_copy at the first place is that I used this name for the namespace few lines above. But I can rename that namespace

47

good spot. we do have tests in ranges version but no tests in classic

libcxx/docs/Status/RangesAlgorithms.csv

 Write,replace,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
 Write,replace_if,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
 Write,replace_copy,Nikolas Klauser,`D129806 <https://llvm.org/D129806>`_,Under review
 Write,replace_copy_if,Nikolas Klauser,`D129806 <https://llvm.org/D129806>`_,Under review
 Write,swap_ranges,Nikolas Klauser,`D116303 <https://llvm.org/D116303>`_,✅
 Write,reverse_copy,Nikolas Klauser,`D127211 <https://llvm.org/D127211>`_,✅
 Write,rotate_copy,Nikolas Klauser,`D127211 <https://llvm.org/D127211>`_,✅
 Write,sample,Not assigned,n/a,Not started
-Write,unique_copy,Not assigned,n/a,Not started
+Write,unique_copy,Hui Xie,`D130404 <https://llvm.org/D130404>`,✅
 Write,partition_copy,Konstantin Varlamov,`D130070 <https://llvm.org/D130070>`_,✅
 Write,partial_sort_copy,Konstantin Varlamov,n/a,In progress
 Merge,merge,Hui Xie,`D128611 <https://llvm.org/D128611>`_,✅
 Merge,set_difference,Hui Xie,`D128983 <https://llvm.org/D128983>`_,✅
 Merge,set_intersection,Hui Xie,`D129233 <https://llvm.org/D129233>`_,✅
 Merge,set_symmetric_difference,Hui Xie,`D129520 <https://llvm.org/D129520>`_,✅
 Merge,set_union,Hui Xie,`D129657 <https://llvm.org/D129657>`_,✅
 Permutation,remove,Nikolas Klauser,`D128618 <https://llvm.org/D128618>`_,✅
 Permutation,remove_if,Nikolas Klauser,`D128618 <https://llvm.org/D128618>`_,✅
 Permutation,reverse,Nikolas Klauser,`D125752 <https://llvm.org/D125752>`_,✅
 Permutation,rotate,Nikolas Klauser,`D124122 <https://llvm.org/D124122>`_,Under review
 Permutation,shuffle,Not assigned,n/a,Not started
-Permutation,unique,Not assigned,n/a,Not started
+Permutation,unique,Hui Xie,`D130404 <https://llvm.org/D130404>`,✅
 Permutation,partition,Konstantin Varlamov,`D129624 <https://llvm.org/D129624>`_,✅
 Permutation,stable_partition,Konstantin Varlamov,`D129624 <https://llvm.org/D129624>`_,✅
 Permutation,sort,Konstantin Varlamov,`D127557 <https://llvm.org/D127557>`_,✅
 Permutation,stable_sort,Konstantin Varlamov,`D127834 <https://llvm.org/D127834>`_,✅
 Permutation,nth_element,Konstantin Varlamov,`D128149 <https://llvm.org/D128149>`_,✅
 Permutation,partial_sort,Konstantin Varlamov,`D128744 <https://llvm.org/D128744>`_,✅
 Permutation,inplace_merge,Not assigned,n/a,Not started
 Permutation,make_heap,Konstantin Varlamov,`D128115 <https://llvm.org/D128115>`_,✅

libcxx/include/__algorithm/adjacent_find.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_ADJACENT_FIND_H
 #define _LIBCPP___ALGORITHM_ADJACENT_FIND_H
 
 #include <__algorithm/comp.h>
+#include <__algorithm/iterator_operations.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _ForwardIterator, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
-adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
+template <class _AlgPolicy, class _Iter, class _Sent, class _BinaryPredicate>
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _Iter
+__adjacent_find(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) {
   if (__first != __last) {
-    _ForwardIterator __i = __first;
+    _Iter __i = __first;
     while (++__i != __last) {
       if (__pred(*__first, *__i))
         return __first;
       __first = __i;
     }
   }
-  return __last;
+  return _IterOps<_AlgPolicy>::next(std::move(__first), std::move(__last));
+}
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
+adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
+  return std::__adjacent_find<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __pred);
 }
 
 template <class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
+_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
 adjacent_find(_ForwardIterator __first, _ForwardIterator __last) {
   typedef typename iterator_traits<_ForwardIterator>::value_type __v;
-  return _VSTD::adjacent_find(__first, __last, __equal_to<__v>());
+  return std::adjacent_find(__first, __last, __equal_to<__v>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_ADJACENT_FIND_H

libcxx/include/__algorithm/ranges_unique.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_RANGES_UNIQUE_H
 #define _LIBCPP___ALGORITHM_RANGES_UNIQUE_H
 
+#include <__algorithm/iterator_operations.h>
 #include <__algorithm/make_projected.h>
 #include <__algorithm/unique.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>

 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __unique {
 
   struct __fn {
-
-  template <permutable _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
-            indirect_equivalence_relation<projected<_Iter, _Proj>> _Comp = ranges::equal_to>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  subrange<_Iter> operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__first; (void)__last; (void)__comp; (void)__proj;
-    return {};
+    template <
+        permutable _Iter,
+        sentinel_for<_Iter> _Sent,
+        class _Proj                                                  = identity,
+    _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+    operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+      auto __ret = std::__unique<_RangeAlgPolicy>(
+          std::move(__first), std::move(__last), ranges::__make_projected_comp(__comp, __proj));
+      return {std::move(__ret.first), std::move(__ret.second)};
     }
 
-  template <forward_range _Range, class _Proj = identity,
-            indirect_equivalence_relation<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
+    template <
+        forward_range _Range,
+        class _Proj                                                               = identity,
       requires permutable<iterator_t<_Range>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_subrange_t<_Range> operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__range; (void)__comp; (void)__proj;
-    return {};
+    _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+    operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
+      auto __ret = std::__unique<_RangeAlgPolicy>(
+          ranges::begin(__range), ranges::end(__range), ranges::__make_projected_comp(__comp, __proj));
+      return {std::move(__ret.first), std::move(__ret.second)};
     }
-
   };
 
 } // namespace __unique
 
 inline namespace __cpo {
   inline constexpr auto unique = __unique::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #endif // _LIBCPP___ALGORITHM_RANGES_UNIQUE_H

libcxx/include/__algorithm/ranges_unique_copy.h

 #include <__algorithm/unique_copy.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <__iterator/projected.h>
+#include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
struct __fn {
   requires indirectly_copyable<_InIter, _OutIter> &&
             (forward_iterator<_InIter> ||
             (input_iterator<_OutIter> && same_as<iter_value_t<_InIter>, iter_value_t<_OutIter>>) ||
             indirectly_copyable_storable<_InIter, _OutIter>)
   _LIBCPP_HIDE_FROM_ABI constexpr
   unique_copy_result<_InIter, _OutIter>
   operator()(_InIter __first, _Sent __last, _OutIter __result, _Comp __comp = {}, _Proj __proj = {}) const {
     // TODO: implement
+
     (void)__first; (void)__last; (void)__result; (void)__comp; (void)__proj;
     return {};
   }
 
   template <input_range _Range, weakly_incrementable _OutIter, class _Proj = identity,
             indirect_equivalence_relation<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
   requires indirectly_copyable<iterator_t<_Range>, _OutIter> &&
             (forward_iterator<iterator_t<_Range>> ||
inline namespace __cpo {
   inline constexpr auto unique_copy = __unique_copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #endif // _LIBCPP___ALGORITHM_RANGES_UNIQUE_COPY_H

libcxx/include/__algorithm/unique.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_UNIQUE_H
 #define _LIBCPP___ALGORITHM_UNIQUE_H
 
 #include <__algorithm/adjacent_find.h>
 #include <__algorithm/comp.h>
+#include <__algorithm/iterator_operations.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // unique
 
-template <class _ForwardIterator, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
-unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
-{
-    __first = _VSTD::adjacent_find<_ForwardIterator, _BinaryPredicate&>(__first, __last, __pred);
-    if (__first != __last)
-    {
-        // ...  a  a  ?  ...
-        //      f     i
-        _ForwardIterator __i = __first;
-        for (++__i; ++__i != __last;)
-            if (!__pred(*__first, *__i))
-                *++__first = _VSTD::move(*__i);
-        ++__first;
-    }
-    return __first;
+template <class _AlgPolicy, class _Iter, class _Sent, class _BinaryPredicate>
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 std::pair<_Iter, _Iter>
+__unique(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) {
+  __first = std::__adjacent_find<_AlgPolicy>(__first, __last, __pred);
+  if (__first != __last) {
+    _Iter __i = __first;
+        *++__first = _IterOps<_AlgPolicy>::__iter_move(__i);
+    return std::pair<_Iter, _Iter>(std::move(++__first), std::move(__i));
+  }
+  return std::pair<_Iter, _Iter>(__first, __first);
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
+unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
+  return std::__unique<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __pred).first;
 }
 
 template <class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-_ForwardIterator
-unique(_ForwardIterator __first, _ForwardIterator __last)
-{
-    typedef typename iterator_traits<_ForwardIterator>::value_type __v;
-    return _VSTD::unique(__first, __last, __equal_to<__v>());
+_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
+unique(_ForwardIterator __first, _ForwardIterator __last) {
+  return std::unique(__first, __last, __equal_to<__v>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_UNIQUE_H

libcxx/include/__algorithm/unique_copy.h

if (__first != __last)
         *__result = __t;
         ++__result;
         while (++__first != __last)
         {
             if (!__pred(__t, *__first))
             {
                 __t = *__first;
                 *__result = __t;
                 ++__result;
             }
         }
     }
     return __result;
 }
 
 template <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator>
 _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
 __unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
               forward_iterator_tag, output_iterator_tag)
 {
+
     if (__first != __last)
     {
         _ForwardIterator __i = __first;
         *__result = *__i;
         ++__result;
         while (++__first != __last)
         {
             if (!__pred(*__i, *__first))
__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred,
     if (__first != __last)
     {
         *__result = *__first;
         while (++__first != __last)
             if (!__pred(*__result, *__first))
                 *++__result = *__first;
         ++__result;
     }
     return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred)
 {
     return _VSTD::__unique_copy<_BinaryPredicate&>(__first, __last, __result, __pred,

libcxx/include/algorithm

constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
                             Proj1 proj1 = {}, Proj2 proj2 = {});                                   // Since C++20
   
   template<input_range R1, input_range R2, class Proj1 = identity,
            class Proj2 = identity,
            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
     constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
                             Proj1 proj1 = {}, Proj2 proj2 = {});                                   // Since C++20
+
+  template<permutable I, sentinel_for<I> S, class Proj = identity,
+           indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+    constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});                    // Since C++20
+  
+  template<forward_range R, class Proj = identity,
+           indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+    requires permutable<iterator_t<R>>
+    constexpr borrowed_subrange_t<R>
+      unique(R&& r, C comp = {}, Proj proj = {});                                                  // Since C++20
+
+  template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
+           indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+    requires indirectly_copyable<I, O> &&
+             (forward_iterator<I> ||
+              (input_iterator<O> && same_as<iter_value_t<I>, iter_value_t<O>>) ||
+              indirectly_copyable_storable<I, O>)
+    constexpr unique_copy_result<I, O>
+      unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});                         // Since C++20
+ 
+  template<input_range R, weakly_incrementable O, class Proj = identity,
+           indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+    requires indirectly_copyable<iterator_t<R>, O> &&
+             (forward_iterator<iterator_t<R>> ||
+              (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
+              indirectly_copyable_storable<iterator_t<R>, O>)
+    constexpr unique_copy_result<borrowed_iterator_t<R>, O>
+      unique_copy(R&& r, O result, C comp = {}, Proj proj = {});                                   // Since C++20
 }
 
     constexpr bool     // constexpr in C++20
     all_of(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     any_of(InputIterator first, InputIterator last, Predicate pred);

 #include <__algorithm/ranges_set_symmetric_difference.h>
 #include <__algorithm/ranges_set_union.h>
 #include <__algorithm/ranges_sort.h>
 #include <__algorithm/ranges_sort_heap.h>
 #include <__algorithm/ranges_stable_partition.h>
 #include <__algorithm/ranges_stable_sort.h>
 #include <__algorithm/ranges_swap_ranges.h>
 #include <__algorithm/ranges_transform.h>
+#include <__algorithm/ranges_unique.h>
+#include <__algorithm/ranges_unique_copy.h>
 #include <__algorithm/ranges_upper_bound.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_copy.h>
 #include <__algorithm/remove_copy_if.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/replace.h>
 #include <__algorithm/replace_copy.h>
 #include <__algorithm/replace_copy_if.h>

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp

#endif
     if (!std::is_constant_evaluated()) { (void)std::ranges::stable_sort(a, Less(&copies)); assert(copies == 0); }
 #if TEST_STD_VER > 20
     //(void)std::ranges::starts_with(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
 #endif
     (void)std::ranges::transform(first, last, first2, UnaryTransform(&copies)); assert(copies == 0);
     (void)std::ranges::transform(a, first2, UnaryTransform(&copies)); assert(copies == 0);
     (void)std::ranges::transform(first, mid, mid, last, first2, BinaryTransform(&copies)); assert(copies == 0);
     (void)std::ranges::transform(a, b, first2, BinaryTransform(&copies)); assert(copies == 0);
-    //(void)std::ranges::unique(first, last, Equal(&copies)); assert(copies == 0);
-    //(void)std::ranges::unique(a, Equal(&copies)); assert(copies == 0);
-    //(void)std::ranges::unique_copy(first, last, first2, Equal(&copies)); assert(copies == 0);
-    //(void)std::ranges::unique_copy(a, first2, Equal(&copies)); assert(copies == 0);
+    (void)std::ranges::unique(first, last, Equal(&copies)); assert(copies == 0);
+    (void)std::ranges::unique(a, Equal(&copies)); assert(copies == 0);
+    (void)std::ranges::unique_copy(first, last, first2, Equal(&copies)); assert(copies == 0);
+    (void)std::ranges::unique_copy(a, first2, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::upper_bound(first, last, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::upper_bound(a, value, Less(&copies)); assert(copies == 0);
 
     return true;
 }
 
 int main(int, char**)
 {
     all_the_algorithms();
     static_assert(all_the_algorithms());
 
     return 0;
 }

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp

#endif
     if (!std::is_constant_evaluated()) { (void)std::ranges::stable_sort(a, Less(), Proj(&copies)); assert(copies == 0); }
 #if TEST_STD_VER > 20
     //(void)std::ranges::starts_with(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
 #endif
     (void)std::ranges::transform(first, last, first2, UnaryTransform(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(a, first2, UnaryTransform(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(first, mid, mid, last, first2, BinaryTransform(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(a, b, first2, BinaryTransform(), Proj(&copies), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::unique(first, last, Equal(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::unique(a, Equal(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::unique_copy(first, last, first2, Equal(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::unique_copy(a, first2, Equal(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::unique(first, last, Equal(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::unique(a, Equal(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::unique_copy(first, last, first2, Equal(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::unique_copy(a, first2, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::upper_bound(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::upper_bound(a, value, Less(), Proj(&copies)); assert(copies == 0);
 
     return true;
 }
 
 int main(int, char**)
 {
     all_the_algorithms();
     static_assert(all_the_algorithms());
 
     return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/ranges_unique.pass.cpp

 
 #include <algorithm>
 #include <array>
 #include <concepts>
 #include <functional>
 #include <ranges>
 
 #include "almost_satisfies_types.h"
+#include "counting_predicates.h"
+#include "counting_projection.h"
 #include "test_iterators.h"
 
-// TODO: SFINAE tests.
+template <class Iter = int*, class Sent = int*, class Comp = std::ranges::equal_to, class Proj = std::identity>
+concept HasUniqueIter =
+    requires(Iter&& iter, Sent&& sent, Comp&& comp, Proj&& proj) {
+      std::ranges::unique(
+          std::forward<Iter>(iter), std::forward<Sent>(sent), std::forward<Comp>(comp), std::forward<Proj>(proj));
+    };
+
+static_assert(HasUniqueIter<int*, int*>);
+
+// !permutable<I>
+static_assert(!HasUniqueIter<PermutableNotForwardIterator>);
+static_assert(!HasUniqueIter<PermutableNotSwappable>);
+
+// !sentinel_for<S, I>
+static_assert(!HasUniqueIter<int*, SentinelForNotSemiregular>);
+
+// !indirect_equivalence_relation<Comp, projected<I, Proj>>
+static_assert(!HasUniqueIter<int*, int*, ComparatorNotCopyable<int>>);
+
+template <class Range, class Comp = std::ranges::equal_to, class Proj = std::identity>
+concept HasUniqueRange =
+    requires(Range&& range, Comp&& comp, Proj&& proj) {
+      std::ranges::unique(std::forward<Range>(range), std::forward<Comp>(comp), std::forward<Proj>(proj));
+    };
+
+template <class T>
+using R = UncheckedRange<T>;
+
+static_assert(HasUniqueRange<R<int*>>);
+
+// !forward_range<R>
+static_assert(!HasUniqueRange<ForwardRangeNotDerivedFrom>);
+static_assert(!HasUniqueRange<ForwardRangeNotIncrementable>);
+
+// permutable<ranges::iterator_t<R>>
+static_assert(!HasUniqueRange<R<PermutableNotForwardIterator>>);
+static_assert(!HasUniqueRange<R<PermutableNotSwappable>>);
+
+// !indirect_equivalence_relation<Comp, projected<ranges::iterator_t<R>, Proj>>
+static_assert(!HasUniqueRange<R<int*>, ComparatorNotCopyable<int>>);
+
+template <class Iter, template <class> class SentWrapper, std::size_t N1, std::size_t N2>
+constexpr void testIncludesImpl(std::array<int, N1> input, std::array<int, N2> expected) {
+  using Sent = SentWrapper<Iter>;
+
+  // iterator overload
+  {
+    auto in = input;
+    std::same_as<std::ranges::subrange<Iter>> decltype(auto) result =
+        std::ranges::unique(Iter{in.data()}, Sent{Iter{in.data() + in.size()}});
+    assert(std::ranges::equal(std::ranges::subrange<Iter>{Iter{in.data()}, result.begin()}, expected));
+    assert(base(result.end()) == in.data() + in.size());
+  }
+
+  // range overload
+  {
+    auto in = input;
+    std::ranges::subrange r{Iter{in.data()}, Sent{Iter{in.data() + in.size()}}};
+    std::same_as<std::ranges::subrange<Iter>> decltype(auto) result = std::ranges::unique(r);
+    assert(std::ranges::equal(std::ranges::subrange<Iter>{Iter{in.data()}, result.begin()}, expected));
+    assert(base(result.end()) == in.data() + in.size());
+  }
+}
+
+template <class Iter, template <class> class SentWrapper>
+constexpr void testImpl() {
+  // no consecutive elements
+  {
+    std::array in{1, 2, 3, 2, 1};
+    std::array expected{1, 2, 3, 2, 1};
+    testIncludesImpl<Iter, SentWrapper>(in, expected);
+  }
+
+  // one group of consecutive elements
+  {
+    std::array in{2, 3, 3, 3, 4, 3};
+    std::array expected{2, 3, 4, 3};
+    testIncludesImpl<Iter, SentWrapper>(in, expected);
+  }
+
+  // multiple groups of consecutive elements
+  {
+    std::array in{2, 3, 3, 3, 4, 3, 3, 5, 5, 5};
+    std::array expected{2, 3, 4, 3, 5};
+    testIncludesImpl<Iter, SentWrapper>(in, expected);
+  }
+
+  // all the same
+  {
+    std::array in{1, 1, 1, 1, 1, 1};
+    std::array expected{1};
+    testIncludesImpl<Iter, SentWrapper>(in, expected);
+  }
+
+  // empty range
+  {
+    std::array<int, 0> in{};
+    std::array<int, 0> expected{};
+    testIncludesImpl<Iter, SentWrapper>(in, expected);
+  }
+}
+
+template <template <class> class SentWrapper>
+constexpr void withAllPermutationsOfIter() {
+  testImpl<forward_iterator<int*>, SentWrapper>();
+  testImpl<bidirectional_iterator<int*>, SentWrapper>();
+  testImpl<random_access_iterator<int*>, SentWrapper>();
+  testImpl<contiguous_iterator<int*>, SentWrapper>();
+  testImpl<int*, SentWrapper>();
+}
 
 constexpr bool test() {
-  // TODO: main tests.
-  // TODO: A custom comparator works.
-  // TODO: A custom projection works.
+  withAllPermutationsOfIter<std::type_identity_t>();
+  withAllPermutationsOfIter<sentinel_wrapper>();
+
+  struct Data {
+    int data;
+  };
+
+  // Test custom comparator
+  {
+    std::array input{Data{4}, Data{8}, Data{8}, Data{8}};
+    std::array expected{Data{4}, Data{8}};
+    const auto comp = [](const Data& x, const Data& y) { return x.data == y.data; };
+
+    // iterator overload
+    {
+      auto in     = input;
+      auto result = std::ranges::unique(in.begin(), in.end(), comp);
+      assert(std::ranges::equal(in.begin(), result.begin(), expected.begin(), expected.end(), comp));
+      assert(base(result.end()) == in.end());
+    }
+
+    // range overload
+    {
+      auto in     = input;
+      auto result = std::ranges::unique(in, comp);
+      assert(std::ranges::equal(in.begin(), result.begin(), expected.begin(), expected.end(), comp));
+      assert(base(result.end()) == in.end());
+    }
+  }
+
+  // Test custom projection
+  {
+    std::array input{Data{4}, Data{8}, Data{8}, Data{8}};
+    std::array expected{Data{4}, Data{8}};
+
+    const auto proj = &Data::data;
+
+    // iterator overload
+    {
+      auto in     = input;
+      auto result = std::ranges::unique(in.begin(), in.end(), {}, proj);
+      assert(std::ranges::equal(in.begin(), result.begin(), expected.begin(), expected.end(), {}, proj, proj));
+      assert(base(result.end()) == in.end());
+    }
+
+    // range overload
+    {
+      auto in     = input;
+      auto result = std::ranges::unique(in, {}, proj);
+      assert(std::ranges::equal(in.begin(), result.begin(), expected.begin(), expected.end(), {}, proj, proj));
+      assert(base(result.end()) == in.end());
+    }
+  }
+
+  // Complexity: For nonempty ranges, exactly (last - first) - 1 applications of the corresponding predicate
+  // and no more than twice as many applications of any projection.
+  {
+    std::array input{1, 2, 3, 3, 3, 4, 3, 3, 5, 5, 6, 6, 1};
+    std::array expected{1, 2, 3, 4, 3, 5, 6, 1};
+    // iterator overload
+    {
+      auto in          = input;
+      int numberOfComp = 0;
+      int numberOfProj = 0;
+      auto result      = std::ranges::unique(
+          in.begin(),
+          in.end(),
+          counting_predicate{std::ranges::equal_to{}, numberOfComp},
+          counting_projection{numberOfProj});
+      assert(std::ranges::equal(in.begin(), result.begin(), expected.begin(), expected.end()));
+      assert(base(result.end()) == in.end());
+      assert(numberOfComp == in.size() - 1);
+      assert(numberOfProj <= static_cast<int>(2 * (in.size() - 1)));
+    }
+    // range overload
+    {
+      auto in          = input;
+      int numberOfComp = 0;
+      int numberOfProj = 0;
+      auto result      = std::ranges::unique(
+          in, counting_predicate{std::ranges::equal_to{}, numberOfComp}, counting_projection{numberOfProj});
+      assert(std::ranges::equal(in.begin(), result.begin(), expected.begin(), expected.end()));
+      assert(base(result.end()) == in.end());
+      assert(numberOfComp == in.size() - 1);
+      assert(numberOfProj <= static_cast<int>(2 * (in.size() - 1)));
+    }
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/ranges_unique_copy.pass.cpp

 
 // TODO: SFINAE tests.
 
 constexpr bool test() {
   // TODO: main tests.
   // TODO: A custom comparator works.
   // TODO: A custom projection works.
 
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp

test()
     assert(base(r) == ji + 3);
     assert(ji[0] == 0);
     assert(ji[1] == 1);
     assert(ji[2] == 2);
 }
 
 int main(int, char**)
 {
+    test<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
     test<cpp17_input_iterator<const int*>, cpp17_output_iterator<int*> >();
     test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
     test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
     test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
     test<cpp17_input_iterator<const int*>, int*>();
 
     test<forward_iterator<const int*>, cpp17_output_iterator<int*> >();
     test<forward_iterator<const int*>, forward_iterator<int*> >();

libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp

constexpr bool test_all() {
   using std::ranges::reverse_copy_result;
   using std::ranges::rotate_copy_result;
   using std::ranges::set_difference_result;
   using std::ranges::set_intersection_result;
   using std::ranges::set_symmetric_difference_result;
   using std::ranges::set_union_result;
   using std::ranges::swap_ranges_result;
   using std::ranges::unary_transform_result;
-  //using std::ranges::unique_copy_result;
+  using std::ranges::unique_copy_result;
 
   auto unary_pred = [](int i) { return i > 0; };
   auto binary_pred = [](int i, int j) { return i < j; };
   //auto gen = [] { return 42; };
   //std::mt19937 rand_gen;
 
   std::array in = {1, 2, 3};
   std::array in2 = {4, 5, 6};
constexpr bool test_all() {
   dangling_1st(std::ranges::find_first_of, in, in2);
   dangling_1st(std::ranges::adjacent_find, in);
   dangling_1st<mismatch_result<dangling, int*>>(std::ranges::mismatch, in, in2);
   dangling_2nd<mismatch_result<int*, dangling>>(std::ranges::mismatch, in, in2);
   dangling_both<mismatch_result<dangling, dangling>>(std::ranges::mismatch, in, in2);
   dangling_1st(std::ranges::partition_point, in, unary_pred);
   dangling_1st(std::ranges::lower_bound, in, x);
   dangling_1st(std::ranges::upper_bound, in, x);
-  //dangling_1st(std::ranges::equal_range, in, x);
+  dangling_1st(std::ranges::equal_range, in, x);
   dangling_1st(std::ranges::min_element, in);
   dangling_1st(std::ranges::max_element, in);
   dangling_1st<minmax_result<dangling>>(std::ranges::minmax_element, in);
   dangling_1st(std::ranges::search, in, in2);
   dangling_1st(std::ranges::search_n, in, count, x);
   dangling_1st(std::ranges::find_end, in, in2);
   dangling_1st(std::ranges::is_sorted_until, in);
   //dangling_1st(std::ranges::is_heap_until, in);
constexpr bool test_all() {
   dangling_1st(std::ranges::replace_if, in, std::identity{}, x);
   //dangling_1st(std::ranges::replace_copy, in, out, x, x);
   //dangling_1st(std::ranges::replace_copy_if, in, out, x, x);
   dangling_1st<swap_ranges_result<dangling, int*>>(std::ranges::swap_ranges, in, in2);
   dangling_2nd<swap_ranges_result<int*, dangling>>(std::ranges::swap_ranges, in, in2);
   dangling_both<swap_ranges_result<dangling, dangling>>(std::ranges::swap_ranges, in, in2);
   dangling_1st<reverse_copy_result<dangling, int*>>(std::ranges::reverse_copy, in, out);
   dangling_1st<rotate_copy_result<dangling, int*>>(std::ranges::rotate_copy, in, mid, out);
-  //dangling_1st<unique_copy_result<dangling, int*>>(std::ranges::unique_copy, in, out);
+  dangling_1st<unique_copy_result<dangling, int*>>(std::ranges::unique_copy, in, out);
   dangling_1st<partition_copy_result<dangling, int*, int*>>(std::ranges::partition_copy, in, out, out2, unary_pred);
   //dangling_1st<partial_sort_copy_result<dangling, int*>>(std::ranges::partial_sort_copy, in, in2);
   //dangling_2nd<partial_sort_copy_result<int*, dangling>>(std::ranges::partial_sort_copy, in, in2);
   //dangling_both<partial_sort_copy_result<dangling, dangling>>(std::ranges::partial_sort_copy, in, in2);
   dangling_1st<merge_result<dangling, int*, int*>>(std::ranges::merge, in, in2, out);
   dangling_2nd<merge_result<int*, dangling, int*>>(std::ranges::merge, in, in2, out);
   dangling_both<merge_result<dangling, dangling, int*>>(std::ranges::merge, in, in2, out);
   dangling_1st<set_difference_result<dangling, int*>>(std::ranges::set_difference, in, in2, out);
constexpr bool test_all() {
   dangling_1st<set_union_result<dangling, int*, int*>>(std::ranges::set_union, in, in2, out);
   dangling_2nd<set_union_result<int*, dangling, int*>>(std::ranges::set_union, in, in2, out);
   dangling_both<set_union_result<dangling, dangling, int*>>(std::ranges::set_union, in, in2, out);
   dangling_1st(std::ranges::remove, in, x);
   dangling_1st(std::ranges::remove_if, in, unary_pred);
   dangling_1st(std::ranges::reverse, in);
   //dangling_1st(std::ranges::rotate, in, mid);
   //dangling_1st(std::ranges::shuffle, in, rand_gen);
-  //dangling_1st(std::ranges::unique, in);
+  dangling_1st(std::ranges::unique, in);
   dangling_1st(std::ranges::partition, in, unary_pred);
   if (!std::is_constant_evaluated())
     dangling_1st(std::ranges::stable_partition, in, unary_pred);
   dangling_1st(std::ranges::sort, in);
   if (!std::is_constant_evaluated())
     dangling_1st(std::ranges::stable_sort, in);
   dangling_1st(std::ranges::partial_sort, in, mid);
   dangling_1st(std::ranges::nth_element, in, mid);

libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.pass.cpp

constexpr bool test_all() {
   //test(std::ranges::is_heap, in, binary_pred);
   //test(std::ranges::is_heap_until, in, binary_pred);
   //std::ranges::clamp(2, 1, 3, binary_pred);
   //test(std::ranges::is_permutation, in, in2, binary_pred);
   test(std::ranges::copy_if, in, out, unary_pred);
   //test(std::ranges::remove_copy_if, in, out, unary_pred);
   test(std::ranges::replace_if, in, unary_pred, x);
   //test(std::ranges::replace_copy_if, in, out, unary_pred, x);
-  //test(std::ranges::unique_copy, in, out, binary_pred);
+  test(std::ranges::unique_copy, in, out, binary_pred);
   test(std::ranges::partition_copy, in, out, out2, unary_pred);
   //test(std::ranges::partial_sort_copy, in, in2, binary_pred);
   test(std::ranges::merge, in, in2, out, binary_pred);
   test(std::ranges::set_difference, in, in2, out, binary_pred);
   test(std::ranges::set_intersection, in, in2, out, binary_pred);
   test(std::ranges::set_symmetric_difference, in, in2, out, binary_pred);
   test(std::ranges::set_union, in, in2, out, binary_pred);
   test(std::ranges::remove_if, in, unary_pred);
-  //test(std::ranges::unique, in, binary_pred);
+  test(std::ranges::unique, in, binary_pred);
   test(std::ranges::partition, in, unary_pred);
   if (!std::is_constant_evaluated())
     test(std::ranges::stable_partition, in, unary_pred);
   test(std::ranges::sort, in, binary_pred);
   if (!std::is_constant_evaluated())
     test(std::ranges::stable_sort, in, binary_pred);
   test_mid(std::ranges::partial_sort, in, mid, binary_pred);
   test_mid(std::ranges::nth_element, in, mid, binary_pred);

libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.pass.cpp

constexpr bool test_all() {
   test(std::ranges::replace, in, x, a, &Bar::val);
   test(std::ranges::replace_if, in, &Foo::unary_pred, a, &Bar::val);
   //test(std::ranges::replace_copy, in, out, x, a, &Bar::val);
   //test(std::ranges::replace_copy_if, in, out, pred, a, &Bar::val);
   // `swap_ranges` has neither a projection nor a predicate.
   // `reverse_copy` has neither a projection nor a predicate.
   // `rotate_copy` has neither a projection nor a predicate.
   // `sample` has no requirement that the given generator be invoked via `std::invoke`.
-  //test(std::ranges::unique_copy, in, out, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::unique_copy, in, out, &Foo::binary_pred, &Bar::val);
   test(std::ranges::partition_copy, in, out, out2, &Foo::unary_pred, &Bar::val);
   //test(std::ranges::partial_sort_copy, in, in2, &Foo::binary_pred, &Bar::val);
   test(std::ranges::merge, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::set_difference, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::set_intersection, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::set_symmetric_difference, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::set_union, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::remove, in, x, &Bar::val);
   test(std::ranges::remove_if, in, &Foo::unary_pred, &Bar::val);
   // `reverse` has neither a projection nor a predicate.
   // `rotate` has neither a projection nor a predicate.
   // `shuffle` has neither a projection nor a predicate.
-  //test(std::ranges::unique, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::unique, in, &Foo::binary_pred, &Bar::val);
   test(std::ranges::partition, in, &Foo::unary_pred, &Bar::val);
   if (!std::is_constant_evaluated())
     test(std::ranges::stable_partition, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::sort, in, &Foo::binary_pred, &Bar::val);
   if (!std::is_constant_evaluated())
     test(std::ranges::stable_sort, in, &Foo::binary_pred, &Bar::val);
   test_mid(std::ranges::partial_sort, in, mid, &Foo::binary_pred, &Bar::val);
   test_mid(std::ranges::nth_element, in, mid, &Foo::binary_pred, &Bar::val);

libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp

//test(std::ranges::remove_copy_if, in, out, unary_pred);
     test(std::ranges::replace_if, in, unary_pred, x);
     //test(std::ranges::replace_copy, in, out, x, x);
     //test(std::ranges::replace_copy_if, in, out, unary_pred, x);
   }
   test(std::ranges::swap_ranges, in, in2);
   if constexpr (std::copyable<T>) {
     test(std::ranges::reverse_copy, in, out);
     test_mid(std::ranges::rotate_copy, in, mid, out);
-    //test(std::ranges::unique_copy, in, out);
+    test(std::ranges::unique_copy, in, out);
     test(std::ranges::partition_copy, in, out, out2, unary_pred);
     //test_mid(std::ranges::partial_sort_copy, in, in2);
     test(std::ranges::merge, in, in2, out);
     test(std::ranges::set_difference, in, in2, out);
     test(std::ranges::set_intersection, in, in2, out);
     test(std::ranges::set_symmetric_difference, in, in2, out);
     test(std::ranges::set_union, in, in2, out);
   }
   test(std::ranges::remove, in, x);
   test(std::ranges::remove_if, in, unary_pred);
   test(std::ranges::reverse, in);
   //test_mid(std::ranges::rotate, in, mid);
   //test(std::ranges::shuffle, in, rand_gen);
   //test(std::ranges::sample, in, out, count, rand_gen);
-  //test(std::ranges::unique, in);
+  test(std::ranges::unique, in);
   test(std::ranges::partition, in, unary_pred);
   // TODO(ranges): `stable_partition` requires `ranges::rotate` to be implemented.
   //if (!std::is_constant_evaluated())
   // test(std::ranges::stable_partition, in, unary_pred);
   test(std::ranges::sort, in);
   // TODO(ranges): `stable_sort` requires `ranges::rotate` to be implemented.
   //if (!std::is_constant_evaluated())
   //  test(std::ranges::stable_sort, in);

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

 //static_assert(test(std::ranges::shuffle, a, g));
 static_assert(test(std::ranges::sort, a));
 static_assert(test(std::ranges::sort_heap, a));
 static_assert(test(std::ranges::stable_partition, a, odd));
 static_assert(test(std::ranges::stable_sort, a));
 //static_assert(test(std::ranges::starts_with, a, a));
 static_assert(test(std::ranges::swap_ranges, a, a));
 static_assert(test(std::ranges::transform, a, a, triple));
-//static_assert(test(std::ranges::unique, a));
-//static_assert(test(std::ranges::unique_copy, a, a));
+static_assert(test(std::ranges::unique, a));
+static_assert(test(std::ranges::unique_copy, a, a));
 static_assert(test(std::ranges::upper_bound, a, 42));
 
 // [memory.syn]
 
 static_assert(test(std::ranges::construct_at, a, 42));
 static_assert(test(std::ranges::destroy, a));
 static_assert(test(std::ranges::destroy, a, a+10));
 static_assert(test(std::ranges::destroy_at, a));