[libcxx-commits] [libcxx] a5c0638 - [libc++][ranges] implement `std::ranges::set_symmetric_difference`
Hui Xie via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Jul 13 13:25:01 PDT 2022
Author: Hui Xie
Date: 2022-07-13T21:24:32+01:00
New Revision: a5c0638dec838fe4c8189d3c72c251c9030f9605
URL: https://github.com/llvm/llvm-project/commit/a5c0638dec838fe4c8189d3c72c251c9030f9605
DIFF: https://github.com/llvm/llvm-project/commit/a5c0638dec838fe4c8189d3c72c251c9030f9605.diff
LOG: [libc++][ranges] implement `std::ranges::set_symmetric_difference`
[libc++][ranges] implement `std::ranges::set_symmetric_difference`
Differential Revision: https://reviews.llvm.org/D129520
Added:
libcxx/include/__algorithm/ranges_set_symmetric_difference.h
libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/ranges_set_symmetric_difference.pass.cpp
Modified:
libcxx/docs/Status/RangesAlgorithms.csv
libcxx/include/CMakeLists.txt
libcxx/include/__algorithm/ranges_set_intersection.h
libcxx/include/__algorithm/set_intersection.h
libcxx/include/__algorithm/set_symmetric_difference.h
libcxx/include/algorithm
libcxx/include/module.modulemap.in
libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
libcxx/test/libcxx/private_headers.verify.cpp
libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.compile.pass.cpp
libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.compile.pass.cpp
libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
Removed:
################################################################################
diff --git a/libcxx/docs/Status/RangesAlgorithms.csv b/libcxx/docs/Status/RangesAlgorithms.csv
index 34ff673a2ecf0..3a3dac2a84f6d 100644
--- a/libcxx/docs/Status/RangesAlgorithms.csv
+++ b/libcxx/docs/Status/RangesAlgorithms.csv
@@ -63,7 +63,7 @@ Write,partial_sort_copy,Not assigned,n/a,Not started
Merge,merge,Hui Xie,`D128611 <https://llvm.org/D128611>`_,✅
Merge,set_
diff erence,Hui Xie,`D128983 <https://llvm.org/D128983>`,✅
Merge,set_intersection,Hui Xie,`D129233 <https://llvm.org/D129233>`,✅
-Merge,set_symmetric_
diff erence,Hui Xie,n/a,Not started
+Merge,set_symmetric_
diff erence,Hui Xie,`D129520 <https://llvm.org/D129520>`,✅
Merge,set_union,Hui Xie,n/a,Not started
Permutation,remove,Nikolas Klauser,`D128618 <https://llvm.org/D128618>`_,✅
Permutation,remove_if,Nikolas Klauser,`D128618 <https://llvm.org/D128618>`_,✅
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 05c7c7b6bbcc7..4951d03ab4700 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -134,6 +134,7 @@ set(files
__algorithm/ranges_search_n.h
__algorithm/ranges_set_
diff erence.h
__algorithm/ranges_set_intersection.h
+ __algorithm/ranges_set_symmetric_
diff erence.h
__algorithm/ranges_set_union.h
__algorithm/ranges_shuffle.h
__algorithm/ranges_sort.h
diff --git a/libcxx/include/__algorithm/ranges_set_intersection.h b/libcxx/include/__algorithm/ranges_set_intersection.h
index dac35cf27060e..05af91ae29e5f 100644
--- a/libcxx/include/__algorithm/ranges_set_intersection.h
+++ b/libcxx/include/__algorithm/ranges_set_intersection.h
@@ -66,7 +66,7 @@ struct __fn {
std::move(__last2),
std::move(__result),
ranges::__make_projected_comp(__comp, __proj1, __proj2));
- return {std::move(__ret.in1), std::move(__ret.in2), std::move(__ret.out)};
+ return {std::move(__ret.__in1_), std::move(__ret.__in2_), std::move(__ret.__out_)};
}
template <
@@ -100,7 +100,7 @@ struct __fn {
ranges::end(__range2),
std::move(__result),
ranges::__make_projected_comp(__comp, __proj1, __proj2));
- return {std::move(__ret.in1), std::move(__ret.in2), std::move(__ret.out)};
+ return {std::move(__ret.__in1_), std::move(__ret.__in2_), std::move(__ret.__out_)};
}
};
diff --git a/libcxx/include/__algorithm/ranges_set_symmetric_
diff erence.h b/libcxx/include/__algorithm/ranges_set_symmetric_
diff erence.h
new file mode 100644
index 0000000000000..c54cf3a651125
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_set_symmetric_
diff erence.h
@@ -0,0 +1,116 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_SET_SYMMETRIC_DIFFERENCE_H
+#define _LIBCPP___ALGORITHM_RANGES_SET_SYMMETRIC_DIFFERENCE_H
+
+#include <__algorithm/in_in_out_result.h>
+#include <__algorithm/make_projected.h>
+#include <__algorithm/set_symmetric_
diff erence.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/mergeable.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _InIter1, class _InIter2, class _OutIter>
+using set_symmetric_
diff erence_result = in_in_out_result<_InIter1, _InIter2, _OutIter>;
+
+namespace __set_symmetric_
diff erence {
+
+struct __fn {
+ template <
+ input_iterator _InIter1,
+ sentinel_for<_InIter1> _Sent1,
+ input_iterator _InIter2,
+ sentinel_for<_InIter2> _Sent2,
+ weakly_incrementable _OutIter,
+ class _Comp = ranges::less,
+ class _Proj1 = identity,
+ class _Proj2 = identity>
+ requires mergeable<_InIter1, _InIter2, _OutIter, _Comp, _Proj1, _Proj2>
+ _LIBCPP_HIDE_FROM_ABI constexpr set_symmetric_
diff erence_result<_InIter1, _InIter2, _OutIter> operator()(
+ _InIter1 __first1,
+ _Sent1 __last1,
+ _InIter2 __first2,
+ _Sent2 __last2,
+ _OutIter __result,
+ _Comp __comp = {},
+ _Proj1 __proj1 = {},
+ _Proj2 __proj2 = {}) const {
+ auto __ret = std::__set_symmetric_
diff erence(
+ std::move(__first1),
+ std::move(__last1),
+ std::move(__first2),
+ std::move(__last2),
+ std::move(__result),
+ ranges::__make_projected_comp(__comp, __proj1, __proj2));
+ return {std::move(__ret.__in1_), std::move(__ret.__in2_), std::move(__ret.__out_)};
+ }
+
+ template <
+ input_range _Range1,
+ input_range _Range2,
+ weakly_incrementable _OutIter,
+ class _Comp = ranges::less,
+ class _Proj1 = identity,
+ class _Proj2 = identity>
+ requires mergeable<
+ iterator_t<_Range1>,
+ iterator_t<_Range2>,
+ _OutIter,
+ _Comp,
+ _Proj1,
+ _Proj2>
+ _LIBCPP_HIDE_FROM_ABI constexpr set_symmetric_
diff erence_result<borrowed_iterator_t<_Range1>,
+ borrowed_iterator_t<_Range2>,
+ _OutIter>
+ operator()(
+ _Range1&& __range1,
+ _Range2&& __range2,
+ _OutIter __result,
+ _Comp __comp = {},
+ _Proj1 __proj1 = {},
+ _Proj2 __proj2 = {}) const {
+ auto __ret = std::__set_symmetric_
diff erence(
+ ranges::begin(__range1),
+ ranges::end(__range1),
+ ranges::begin(__range2),
+ ranges::end(__range2),
+ std::move(__result),
+ ranges::__make_projected_comp(__comp, __proj1, __proj2));
+ return {std::move(__ret.__in1_), std::move(__ret.__in2_), std::move(__ret.__out_)};
+ }
+};
+
+} // namespace __set_symmetric_
diff erence
+
+inline namespace __cpo {
+ inline constexpr auto set_symmetric_
diff erence = __set_symmetric_
diff erence::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+#endif // _LIBCPP___ALGORITHM_RANGES_SET_SYMMETRIC_DIFFERENCE_H
diff --git a/libcxx/include/__algorithm/set_intersection.h b/libcxx/include/__algorithm/set_intersection.h
index e0f5bd140be73..77cc83738d1ff 100644
--- a/libcxx/include/__algorithm/set_intersection.h
+++ b/libcxx/include/__algorithm/set_intersection.h
@@ -25,14 +25,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _InIter1, class _InIter2, class _OutIter>
struct __set_intersection_result {
- _InIter1 in1;
- _InIter2 in2;
- _OutIter out;
+ _InIter1 __in1_;
+ _InIter2 __in2_;
+ _OutIter __out_;
// need a constructor as C++03 aggregate init is hard
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
__set_intersection_result(_InIter1&& __in_iter1, _InIter2&& __in_iter2, _OutIter&& __out_iter)
- : in1(std::move(__in_iter1)), in2(std::move(__in_iter2)), out(std::move(__out_iter)) {}
+ : __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
};
template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
@@ -74,7 +74,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_i
std::move(__last2),
std::move(__result),
__comp)
- .out;
+ .__out_;
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -92,7 +92,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_i
std::move(__result),
__less<typename iterator_traits<_InputIterator1>::value_type,
typename iterator_traits<_InputIterator2>::value_type>())
- .out;
+ .__out_;
}
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__algorithm/set_symmetric_
diff erence.h b/libcxx/include/__algorithm/set_symmetric_
diff erence.h
index 2dbfb35d7be6e..cd532ab5800d7 100644
--- a/libcxx/include/__algorithm/set_symmetric_
diff erence.h
+++ b/libcxx/include/__algorithm/set_symmetric_
diff erence.h
@@ -14,6 +14,7 @@
#include <__algorithm/copy.h>
#include <__config>
#include <__iterator/iterator_traits.h>
+#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -21,55 +22,81 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
-_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
-__set_symmetric_
diff erence(_InputIterator1 __first1, _InputIterator1 __last1,
- _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
-{
- while (__first1 != __last1)
- {
- if (__first2 == __last2)
- return _VSTD::copy(__first1, __last1, __result);
- if (__comp(*__first1, *__first2))
- {
- *__result = *__first1;
- ++__result;
- ++__first1;
- }
- else
- {
- if (__comp(*__first2, *__first1))
- {
- *__result = *__first2;
- ++__result;
- }
- else
- ++__first1;
- ++__first2;
- }
+template <class _InIter1, class _InIter2, class _OutIter>
+struct __set_symmetric_
diff erence_result {
+ _InIter1 __in1_;
+ _InIter2 __in2_;
+ _OutIter __out_;
+
+ // need a constructor as C++03 aggregate init is hard
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
+ __set_symmetric_
diff erence_result(_InIter1&& __in_iter1, _InIter2&& __in_iter2, _OutIter&& __out_iter)
+ : __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
+};
+
+template <class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 __set_symmetric_
diff erence_result<_InIter1, _InIter2, _OutIter>
+__set_symmetric_
diff erence(
+ _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
+ while (__first1 != __last1) {
+ if (__first2 == __last2) {
+ auto __ret1 = std::__copy_impl(std::move(__first1), std::move(__last1), std::move(__result));
+ return __set_symmetric_
diff erence_result<_InIter1, _InIter2, _OutIter>(
+ std::move(__ret1.first), std::move(__first2), std::move((__ret1.second)));
+ }
+ if (__comp(*__first1, *__first2)) {
+ *__result = *__first1;
+ ++__result;
+ ++__first1;
+ } else {
+ if (__comp(*__first2, *__first1)) {
+ *__result = *__first2;
+ ++__result;
+ } else {
+ ++__first1;
+ }
+ ++__first2;
}
- return _VSTD::copy(__first2, __last2, __result);
+ }
+ auto __ret2 = std::__copy_impl(std::move(__first2), std::move(__last2), std::move(__result));
+ return __set_symmetric_
diff erence_result<_InIter1, _InIter2, _OutIter>(
+ std::move(__first1), std::move(__ret2.first), std::move((__ret2.second)));
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-_OutputIterator
-set_symmetric_
diff erence(_InputIterator1 __first1, _InputIterator1 __last1,
- _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
-{
- typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
- return _VSTD::__set_symmetric_
diff erence<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_symmetric_
diff erence(
+ _InputIterator1 __first1,
+ _InputIterator1 __last1,
+ _InputIterator2 __first2,
+ _InputIterator2 __last2,
+ _OutputIterator __result,
+ _Compare __comp) {
+ typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
+ return std::__set_symmetric_
diff erence<_Comp_ref>(
+ std::move(__first1),
+ std::move(__last1),
+ std::move(__first2),
+ std::move(__last2),
+ std::move(__result),
+ __comp)
+ .__out_;
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-_OutputIterator
-set_symmetric_
diff erence(_InputIterator1 __first1, _InputIterator1 __last1,
- _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
-{
- return _VSTD::set_symmetric_
diff erence(__first1, __last1, __first2, __last2, __result,
- __less<typename iterator_traits<_InputIterator1>::value_type,
- typename iterator_traits<_InputIterator2>::value_type>());
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator set_symmetric_
diff erence(
+ _InputIterator1 __first1,
+ _InputIterator1 __last1,
+ _InputIterator2 __first2,
+ _InputIterator2 __last2,
+ _OutputIterator __result) {
+ return std::set_symmetric_
diff erence(
+ std::move(__first1),
+ std::move(__last1),
+ std::move(__first2),
+ std::move(__last2),
+ std::move(__result),
+ __less<typename iterator_traits<_InputIterator1>::value_type,
+ typename iterator_traits<_InputIterator2>::value_type>());
}
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index 18d8ef3805e53..f616a031960e9 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -692,6 +692,26 @@ namespace ranges {
ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
+ template<class I1, class I2, class O>
+ using set_symmetric_
diff erence_result = in_in_out_result<I1, I2, O>; // since C++20
+
+ template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+ weakly_incrementable O, class Comp = ranges::less,
+ class Proj1 = identity, class Proj2 = identity>
+ requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+ constexpr set_symmetric_
diff erence_result<I1, I2, O>
+ set_symmetric_
diff erence(I1 first1, S1 last1, I2 first2, S2 last2, O result,
+ Comp comp = {}, Proj1 proj1 = {},
+ Proj2 proj2 = {}); // since C++20
+
+ template<input_range R1, input_range R2, weakly_incrementable O,
+ class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
+ requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+ constexpr set_symmetric_
diff erence_result<borrowed_iterator_t<R1>,
+ borrowed_iterator_t<R2>, O>
+ set_symmetric_
diff erence(R1&& r1, R2&& r2, O result, Comp comp = {},
+ Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
+
}
constexpr bool // constexpr in C++20
@@ -1472,6 +1492,7 @@ template <class BidirectionalIterator, class Compare>
#include <__algorithm/ranges_search_n.h>
#include <__algorithm/ranges_set_
diff erence.h>
#include <__algorithm/ranges_set_intersection.h>
+#include <__algorithm/ranges_set_symmetric_
diff erence.h>
#include <__algorithm/ranges_sort.h>
#include <__algorithm/ranges_sort_heap.h>
#include <__algorithm/ranges_stable_sort.h>
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
index c0ecfac991fd2..25e1c6e6d0e2b 100644
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -373,6 +373,7 @@ module std [system] {
module ranges_search_n { private header "__algorithm/ranges_search_n.h" }
module ranges_set_
diff erence { private header "__algorithm/ranges_set_
diff erence.h" }
module ranges_set_intersection { private header "__algorithm/ranges_set_intersection.h" }
+ module ranges_set_symmetric_
diff erence { private header "__algorithm/ranges_set_symmetric_
diff erence.h" }
module ranges_set_union { private header "__algorithm/ranges_set_union.h" }
module ranges_shuffle { private header "__algorithm/ranges_shuffle.h" }
module ranges_sort { private header "__algorithm/ranges_sort.h" }
diff --git a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
index 0eec04b7837d0..d36eece703483 100644
--- a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
+++ b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
@@ -203,8 +203,8 @@ constexpr bool all_the_algorithms()
(void)std::ranges::set_
diff erence(a, b, first2, Less(&copies)); assert(copies == 0);
(void)std::ranges::set_intersection(first, mid, mid, last, first2, Less(&copies)); assert(copies == 0);
(void)std::ranges::set_intersection(a, b, first2, Less(&copies)); assert(copies == 0);
- //(void)std::ranges::set_symmetric_
diff erence(first, mid, mid, last, first2, Less(&copies)); assert(copies == 0);
- //(void)std::ranges::set_symmetric_
diff erence(a, b, first2, Less(&copies)); assert(copies == 0);
+ (void)std::ranges::set_symmetric_
diff erence(first, mid, mid, last, first2, Less(&copies)); assert(copies == 0);
+ (void)std::ranges::set_symmetric_
diff erence(a, b, first2, Less(&copies)); assert(copies == 0);
//(void)std::ranges::set_union(first, mid, mid, last, first2, Less(&copies)); assert(copies == 0);
//(void)std::ranges::set_union(a, b, first2, Less(&copies)); assert(copies == 0);
(void)std::ranges::sort(first, last, Less(&copies)); assert(copies == 0);
diff --git a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
index b0f3f62f25526..5c43803b5b9e6 100644
--- a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
+++ b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
@@ -194,8 +194,8 @@ constexpr bool all_the_algorithms()
(void)std::ranges::set_
diff erence(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
(void)std::ranges::set_intersection(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
(void)std::ranges::set_intersection(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
- //(void)std::ranges::set_symmetric_
diff erence(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
- //(void)std::ranges::set_symmetric_
diff erence(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::set_symmetric_
diff erence(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::set_symmetric_
diff erence(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
//(void)std::ranges::set_union(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
//(void)std::ranges::set_union(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
(void)std::ranges::sort(first, last, Less(), Proj(&copies)); assert(copies == 0);
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
index f46a967809c16..8e2c43bfbd3a0 100644
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -171,6 +171,7 @@ END-SCRIPT
#include <__algorithm/ranges_search_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_search_n.h'}}
#include <__algorithm/ranges_set_
diff erence.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_set_
diff erence.h'}}
#include <__algorithm/ranges_set_intersection.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_set_intersection.h'}}
+#include <__algorithm/ranges_set_symmetric_
diff erence.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_set_symmetric_
diff erence.h'}}
#include <__algorithm/ranges_set_union.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_set_union.h'}}
#include <__algorithm/ranges_shuffle.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_shuffle.h'}}
#include <__algorithm/ranges_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_sort.h'}}
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.
diff erence/ranges_set_symmetric_
diff erence.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.
diff erence/ranges_set_symmetric_
diff erence.pass.cpp
new file mode 100644
index 0000000000000..4ad1bf8c97d74
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.
diff erence/ranges_set_symmetric_
diff erence.pass.cpp
@@ -0,0 +1,507 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+// weakly_incrementable O, class Comp = ranges::less,
+// class Proj1 = identity, class Proj2 = identity>
+// requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+// constexpr set_symmetric_
diff erence_result<I1, I2, O>
+// set_symmetric_
diff erence(I1 first1, S1 last1, I2 first2, S2 last2, O result,
+// Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
+//
+// template<input_range R1, input_range R2, weakly_incrementable O,
+// class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
+// requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+// constexpr set_symmetric_
diff erence_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
+// set_symmetric_
diff erence(R1&& r1, R2&& r2, O result,
+// Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
+
+#include <algorithm>
+#include <array>
+#include <concepts>
+
+#include "almost_satisfies_types.h"
+#include "MoveOnly.h"
+#include "test_iterators.h"
+#include "../../sortable_helpers.h"
+
+// Test iterator overload's constraints:
+// =====================================
+template <class InIter1 = int*, class Sent1 = int*, class InIter2 = int*, class Sent2 = int*, class OutIter = int*>
+concept HasSetSymmetricDifferenceIter =
+ requires(InIter1&& inIter1, InIter2&& inIter2, OutIter&& outIter, Sent1&& sent1, Sent2&& sent2) {
+ std::ranges::set_symmetric_
diff erence(
+ std::forward<InIter1>(inIter1),
+ std::forward<Sent1>(sent1),
+ std::forward<InIter2>(inIter2),
+ std::forward<Sent2>(sent2),
+ std::forward<OutIter>(outIter));
+ };
+
+static_assert(HasSetSymmetricDifferenceIter<int*, int*, int*, int*, int*>);
+
+// !std::input_iterator<I1>
+static_assert(!HasSetSymmetricDifferenceIter<InputIteratorNotDerivedFrom>);
+
+// !std::sentinel_for<S1, I1>
+static_assert(!HasSetSymmetricDifferenceIter<int*, SentinelForNotSemiregular>);
+
+// !std::input_iterator<I2>
+static_assert(!HasSetSymmetricDifferenceIter<int*, int*, InputIteratorNotDerivedFrom>);
+
+// !std::sentinel_for<S2, I2>
+static_assert(!HasSetSymmetricDifferenceIter<int*, int*, int*, SentinelForNotSemiregular>);
+
+// !std::weakly_incrementable<O>
+static_assert(!HasSetSymmetricDifferenceIter<int*, int*, int*, int*, WeaklyIncrementableNotMovable>);
+
+// !std::mergeable<I1, I2, O, Comp, Proj1, Proj2>
+static_assert(!HasSetSymmetricDifferenceIter<MoveOnly*, MoveOnly*, MoveOnly*, MoveOnly*, MoveOnly*>);
+
+// Test range overload's constraints:
+// =====================================
+
+template <class Range1, class Range2, class OutIter>
+concept HasSetSymmetricDifferenceRange =
+ requires(Range1&& range1, Range2&& range2, OutIter&& outIter) {
+ std::ranges::set_symmetric_
diff erence(
+ std::forward<Range1>(range1), std::forward<Range2>(range2), std::forward<OutIter>(outIter));
+ };
+
+template <class T>
+using R = UncheckedRange<T>;
+
+static_assert(HasSetSymmetricDifferenceRange<R<int*>, R<int*>, int*>);
+
+// !std::input_range<R2>
+static_assert(!HasSetSymmetricDifferenceRange<R<InputIteratorNotDerivedFrom>, R<int*>, int*>);
+
+// !std::input_range<R2>
+static_assert(!HasSetSymmetricDifferenceRange<R<int*>, R<InputIteratorNotDerivedFrom>, int*>);
+
+// !std::weakly_incrementable<O>
+static_assert(!HasSetSymmetricDifferenceRange<R<int*>, R<int*>, WeaklyIncrementableNotMovable >);
+
+// !std::mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+static_assert(!HasSetSymmetricDifferenceRange<R<MoveOnly*>, R<MoveOnly*>, MoveOnly*>);
+
+using std::ranges::set_symmetric_
diff erence_result;
+
+template <class In1, class In2, class Out, std::size_t N1, std::size_t N2, std::size_t N3>
+constexpr void
+testSetSymmetricDifferenceImpl(std::array<int, N1> in1, std::array<int, N2> in2, std::array<int, N3> expected) {
+ // TODO: std::ranges::set_symmetric_
diff erence calls std::ranges::copy
+ // std::ranges::copy(contiguous_iterator<int*>, sentinel_wrapper<contiguous_iterator<int*>>, contiguous_iterator<int*>) doesn't seem to work.
+ // It seems that std::ranges::copy calls std::copy, which unwraps contiguous_iterator<int*> into int*,
+ // and then it failed because there is no == between int* and sentinel_wrapper<contiguous_iterator<int*>>
+ using Sent1 = std::conditional_t<std::contiguous_iterator<In1>, In1, sentinel_wrapper<In1>>;
+ using Sent2 = std::conditional_t<std::contiguous_iterator<In2>, In2, sentinel_wrapper<In2>>;
+
+ // iterator overload
+ {
+ std::array<int, N3> out;
+ std::same_as<set_symmetric_
diff erence_result<In1, In2, Out>> decltype(auto) result =
+ std::ranges::set_symmetric_
diff erence(
+ In1{in1.data()},
+ Sent1{In1{in1.data() + in1.size()}},
+ In2{in2.data()},
+ Sent2{In2{in2.data() + in2.size()}},
+ Out{out.data()});
+ assert(std::ranges::equal(out, expected));
+
+ assert(base(result.in1) == in1.data() + in1.size());
+ assert(base(result.in2) == in2.data() + in2.size());
+ assert(base(result.out) == out.data() + out.size());
+ }
+
+ // range overload
+ {
+ std::array<int, N3> out;
+ std::ranges::subrange r1{In1{in1.data()}, Sent1{In1{in1.data() + in1.size()}}};
+ std::ranges::subrange r2{In2{in2.data()}, Sent2{In2{in2.data() + in2.size()}}};
+ std::same_as<set_symmetric_
diff erence_result<In1, In2, Out>> decltype(auto) result =
+ std::ranges::set_symmetric_
diff erence(r1, r2, Out{out.data()});
+ assert(std::ranges::equal(out, expected));
+
+ assert(base(result.in1) == in1.data() + in1.size());
+ assert(base(result.in2) == in2.data() + in2.size());
+ assert(base(result.out) == out.data() + out.size());
+ }
+}
+
+template <class In1, class In2, class Out>
+constexpr void testImpl() {
+ // range 1 shorter than range2
+ {
+ std::array in1{0, 1, 5, 6, 9, 10};
+ std::array in2{3, 6, 7, 9, 13, 15, 100};
+ std::array expected{0, 1, 3, 5, 7, 10, 13, 15, 100};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 2 shorter than range 1
+ {
+ std::array in1{2, 6, 8, 12, 15, 16};
+ std::array in2{0, 2, 8};
+ std::array expected{0, 6, 12, 15, 16};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 1 and range 2 has the same length but
diff erent elements
+ {
+ std::array in1{2, 6, 8, 12, 15, 16};
+ std::array in2{0, 2, 8, 15, 17, 19};
+ std::array expected{0, 6, 12, 16, 17, 19};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 1 == range 2
+ {
+ std::array in1{0, 1, 2};
+ std::array in2{0, 1, 2};
+ std::array<int, 0> expected{};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 1 is super set of range 2
+ {
+ std::array in1{8, 8, 10, 12, 13};
+ std::array in2{8, 10};
+ std::array expected{8, 12, 13};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 2 is super set of range 1
+ {
+ std::array in1{0, 1, 1};
+ std::array in2{0, 1, 1, 2, 5};
+ std::array expected{2, 5};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 1 and range 2 have no elements in common
+ {
+ std::array in1{7, 7, 9, 12};
+ std::array in2{1, 5, 5, 8, 10};
+ std::array expected{1, 5, 5, 7, 7, 8, 9, 10, 12};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 1 and range 2 have duplicated equal elements
+ {
+ std::array in1{7, 7, 9, 12};
+ std::array in2{7, 7, 7, 13};
+ std::array expected{7, 9, 12, 13};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 1 is empty
+ {
+ std::array<int, 0> in1{};
+ std::array in2{3, 4, 5};
+ std::array expected{3, 4, 5};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // range 2 is empty
+ {
+ std::array in1{3, 4, 5};
+ std::array<int, 0> in2{};
+ std::array expected{3, 4, 5};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // both ranges are empty
+ {
+ std::array<int, 0> in1{};
+ std::array<int, 0> in2{};
+ std::array<int, 0> expected{};
+ testSetSymmetricDifferenceImpl<In1, In2, Out>(in1, in2, expected);
+ }
+
+ // check that ranges::dangling is returned for non-borrowed_range
+ {
+ std::array r1{3, 6, 7, 9};
+ int r2[] = {2, 3, 4, 5, 6};
+ std::array<int, 5> out;
+ std::same_as<set_symmetric_
diff erence_result<std::ranges::dangling, int*, int*>> decltype(auto) result =
+ std::ranges::set_symmetric_
diff erence(NonBorrowedRange<In1>{r1.data(), r1.size()}, r2, out.data());
+ assert(base(result.in2) == r2 + 5);
+ assert(base(result.out) == out.data() + out.size());
+ assert(std::ranges::equal(out, std::array{2, 4, 5, 7, 9}));
+ }
+}
+
+template <class InIter2, class OutIter>
+constexpr void withAllPermutationsOfInIter1() {
+ // C++17 InputIterator may or may not satisfy std::input_iterator
+ testImpl<cpp20_input_iterator<int*>, InIter2, OutIter>();
+ testImpl<forward_iterator<int*>, InIter2, OutIter>();
+ testImpl<bidirectional_iterator<int*>, InIter2, OutIter>();
+ testImpl<random_access_iterator<int*>, InIter2, OutIter>();
+ testImpl<contiguous_iterator<int*>, InIter2, OutIter>();
+}
+
+template <class OutIter>
+constexpr bool withAllPermutationsOfInIter1AndInIter2() {
+ withAllPermutationsOfInIter1<cpp20_input_iterator<int*>, OutIter>();
+ withAllPermutationsOfInIter1<forward_iterator<int*>, OutIter>();
+ withAllPermutationsOfInIter1<bidirectional_iterator<int*>, OutIter>();
+ withAllPermutationsOfInIter1<random_access_iterator<int*>, OutIter>();
+ withAllPermutationsOfInIter1<contiguous_iterator<int*>, OutIter>();
+ return true;
+}
+
+constexpr void runAllIteratorPermutationsTests() {
+ withAllPermutationsOfInIter1AndInIter2<cpp20_output_iterator<int*>>();
+ withAllPermutationsOfInIter1AndInIter2<cpp20_input_iterator<int*>>();
+ withAllPermutationsOfInIter1AndInIter2<forward_iterator<int*>>();
+ withAllPermutationsOfInIter1AndInIter2<bidirectional_iterator<int*>>();
+ withAllPermutationsOfInIter1AndInIter2<random_access_iterator<int*>>();
+ withAllPermutationsOfInIter1AndInIter2<contiguous_iterator<int*>>();
+
+ static_assert(withAllPermutationsOfInIter1AndInIter2<cpp20_output_iterator<int*>>());
+ static_assert(withAllPermutationsOfInIter1AndInIter2<cpp20_input_iterator<int*>>());
+ static_assert(withAllPermutationsOfInIter1AndInIter2<forward_iterator<int*>>());
+ static_assert(withAllPermutationsOfInIter1AndInIter2<bidirectional_iterator<int*>>());
+ static_assert(withAllPermutationsOfInIter1AndInIter2<random_access_iterator<int*>>());
+ static_assert(withAllPermutationsOfInIter1AndInIter2<contiguous_iterator<int*>>());
+}
+
+constexpr bool test() {
+ // check that every element is copied exactly once
+ {
+ std::array<TracedCopy, 5> r1{3, 5, 8, 15, 16};
+ std::array<TracedCopy, 3> r2{1, 3, 8};
+
+ // iterator overload
+ {
+ std::array<TracedCopy, 4> out;
+ auto result = std::ranges::set_symmetric_
diff erence(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data());
+
+ assert(result.in1 == r1.end());
+ assert(result.in2 == r2.end());
+ assert(result.out == out.end());
+ assert(std::ranges::equal(out, std::array<TracedCopy, 4>{1, 5, 15, 16}));
+
+ assert(std::ranges::all_of(out, &TracedCopy::copiedOnce));
+ }
+
+ // range overload
+ {
+ std::array<TracedCopy, 4> out;
+ auto result = std::ranges::set_symmetric_
diff erence(r1, r2, out.data());
+
+ assert(result.in1 == r1.end());
+ assert(result.in2 == r2.end());
+ assert(result.out == out.end());
+ assert(std::ranges::equal(out, std::array<TracedCopy, 4>{1, 5, 15, 16}));
+
+ assert(std::ranges::all_of(out, &TracedCopy::copiedOnce));
+ }
+ }
+
+ struct IntAndOrder {
+ int data;
+ int order;
+
+ constexpr auto operator==(const IntAndOrder& o) const { return data == o.data; }
+ constexpr auto operator<=>(const IntAndOrder& o) const { return data <=> o.data; }
+ };
+
+ // Stable. If [first1, last1) contains m elements that are equivalent to each other and [first2, last2)
+ // contains n elements that are equivalent to them, the first min(m, n) elements are copied from the first
+ // range to the output range, in order.
+ {
+ std::array<IntAndOrder, 5> r1{{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}}};
+ std::array<IntAndOrder, 3> r2{{{0, 5}, {0, 6}, {0, 7}}};
+
+ // iterator overload
+ {
+ std::array<IntAndOrder, 2> out;
+ std::ranges::set_symmetric_
diff erence(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data());
+
+ assert(std::ranges::equal(out, std::array{0, 0}, {}, &IntAndOrder::data));
+ assert(std::ranges::equal(out, std::array{3, 4}, {}, &IntAndOrder::order));
+ }
+
+ // range overload
+ {
+ std::array<IntAndOrder, 2> out;
+ std::ranges::set_symmetric_
diff erence(r1, r2, out.data());
+
+ assert(std::ranges::equal(out, std::array{0, 0}, {}, &IntAndOrder::data));
+ assert(std::ranges::equal(out, std::array{3, 4}, {}, &IntAndOrder::order));
+ }
+ }
+
+ struct Data {
+ int data;
+
+ constexpr bool smallerThan(const Data& o) const { return data < o.data; }
+ };
+
+ // Test custom comparator
+ {
+ std::array r1{Data{4}, Data{8}, Data{12}};
+ std::array r2{Data{8}, Data{9}};
+
+ // iterator overload
+ {
+ std::array<Data, 3> out;
+ auto result = std::ranges::set_symmetric_
diff erence(
+ r1.begin(), r1.end(), r2.begin(), r2.end(), out.data(), [](const Data& x, const Data& y) {
+ return x.data < y.data;
+ });
+
+ assert(std::ranges::equal(out, std::array{4, 9, 12}, {}, &Data::data));
+
+ assert(result.in1 == r1.end());
+ assert(result.in2 == r2.end());
+ assert(result.out == out.end());
+ }
+
+ // range overload
+ {
+ std::array<Data, 3> out;
+ auto result = std::ranges::set_symmetric_
diff erence(r1, r2, out.data(), [](const Data& x, const Data& y) {
+ return x.data < y.data;
+ });
+
+ assert(std::ranges::equal(out, std::array{4, 9, 12}, {}, &Data::data));
+
+ assert(result.in1 == r1.end());
+ assert(result.in2 == r2.end());
+ assert(result.out == out.end());
+ }
+ }
+
+ // Test Projection
+ {
+ std::array r1{Data{1}, Data{3}, Data{5}};
+ std::array r2{Data{2}, Data{3}, Data{5}};
+
+ const auto proj = [](const Data& d) { return d.data; };
+
+ // iterator overload
+ {
+ std::array<Data, 2> out;
+ auto result = std::ranges::set_symmetric_
diff erence(
+ r1.begin(), r1.end(), r2.begin(), r2.end(), out.data(), std::ranges::less{}, proj, proj);
+
+ assert(std::ranges::equal(out, std::array{1, 2}, {}, &Data::data));
+
+ assert(result.in1 == r1.end());
+ assert(result.in2 == r2.end());
+ assert(result.out == out.end());
+ }
+
+ // range overload
+ {
+ std::array<Data, 2> out;
+ auto result = std::ranges::set_symmetric_
diff erence(r1, r2, out.data(), std::ranges::less{}, proj, proj);
+
+ assert(std::ranges::equal(out, std::array{1, 2}, {}, &Data::data));
+
+ assert(result.in1 == r1.end());
+ assert(result.in2 == r2.end());
+ assert(result.out == out.end());
+ }
+ }
+
+ // Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applications of each projection.
+ {
+ struct CompProjs {
+ std::size_t numberOfComp = 0;
+ std::size_t numberOfProj1 = 0;
+ std::size_t numberOfProj2 = 0;
+
+ constexpr auto comp() {
+ return [this](int x, int y) {
+ ++numberOfComp;
+ return x < y;
+ };
+ }
+
+ constexpr auto proj1() {
+ return [this](const Data& d) {
+ ++numberOfProj1;
+ return d.data;
+ };
+ }
+
+ constexpr auto proj2() {
+ return [this](const Data& d) {
+ ++numberOfProj2;
+ return d.data;
+ };
+ }
+ };
+
+ std::array<Data, 1> r1{{{7}}};
+ std::array<Data, 6> r2{{{1}, {2}, {3}, {4}, {5}, {6}}};
+ std::array expected{1, 2, 3, 4, 5, 6, 7};
+
+ const std::size_t maxOperation = 2 * (r1.size() + r2.size()) - 1;
+
+ // iterator overload
+ {
+ std::array<Data, 7> out;
+ CompProjs compProjs{};
+
+ std::ranges::set_symmetric_
diff erence(
+ r1.begin(),
+ r1.end(),
+ r2.begin(),
+ r2.end(),
+ out.data(),
+ compProjs.comp(),
+ compProjs.proj1(),
+ compProjs.proj2());
+
+ assert(std::ranges::equal(out, expected, {}, &Data::data));
+ assert(compProjs.numberOfComp < maxOperation);
+ assert(compProjs.numberOfProj1 < maxOperation);
+ assert(compProjs.numberOfProj2 < maxOperation);
+ }
+
+ // range overload
+ {
+ std::array<Data, 7> out;
+ CompProjs compProjs{};
+
+ std::ranges::set_symmetric_
diff erence(r1, r2, out.data(), compProjs.comp(), compProjs.proj1(), compProjs.proj2());
+
+ assert(std::ranges::equal(out, expected, {}, &Data::data));
+ assert(compProjs.numberOfComp < maxOperation);
+ assert(compProjs.numberOfProj1 < maxOperation);
+ assert(compProjs.numberOfProj2 < maxOperation);
+ }
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ // Cannot static_assert on the entire permutation test because it exceeds the constexpr execution step limit
+ // due to the large number of combination of types of iterators (it is a 3-dimensional cartesian product)
+ // Instead of having one single static_assert that tests all the combinations, in the runAllIteratorPermutationsTests
+ // function, it has lots of smaller static_assert and each of them test 2-dimensional cartesian product which is less
+ // than the step limit.
+ runAllIteratorPermutationsTests();
+
+ return 0;
+}
diff --git a/libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.compile.pass.cpp b/libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.compile.pass.cpp
index 1ff2445ce3f93..a504341be619a 100644
--- a/libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.compile.pass.cpp
+++ b/libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.compile.pass.cpp
@@ -151,8 +151,8 @@ void test_all() {
//in2_pred(std::ranges::partial_sort_copy, in, in2, binary_pred);
in2_out_pred(std::ranges::merge, in, in2, out, binary_pred);
in2_out_pred(std::ranges::set_
diff erence, in, in2, out, binary_pred);
- //in2_out_pred(std::ranges::set_intersection, in, in2, out, binary_pred);
- //in2_out_pred(std::ranges::set_symmetric_
diff erence, in, in2, out, binary_pred);
+ in2_out_pred(std::ranges::set_intersection, in, in2, out, binary_pred);
+ in2_out_pred(std::ranges::set_symmetric_
diff erence, in, in2, out, binary_pred);
//in2_out_pred(std::ranges::set_union, in, in2, out, binary_pred);
in_pred(std::ranges::remove_if, in, unary_pred);
//in_pred(std::ranges::unique, in, binary_pred);
diff --git a/libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.compile.pass.cpp b/libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.compile.pass.cpp
index c86d85f2086d8..192d32dc1b303 100644
--- a/libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.compile.pass.cpp
+++ b/libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.compile.pass.cpp
@@ -192,8 +192,8 @@ void test_all() {
//in2_pred(std::ranges::partial_sort_copy, in, in2, &Foo::binary_pred, &Bar::val);
in2_out_pred(std::ranges::merge, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
in2_out_pred(std::ranges::set_
diff erence, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
- //in2_out_pred(std::ranges::set_intersection, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
- //in2_out_pred(std::ranges::set_symmetric_
diff erence, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
+ in2_out_pred(std::ranges::set_intersection, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
+ in2_out_pred(std::ranges::set_symmetric_
diff erence, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
//in2_out_pred(std::ranges::set_union, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
in_val(std::ranges::remove, in, x, &Bar::val);
in_pred(std::ranges::remove_if, in, &Foo::unary_pred, &Bar::val);
diff --git a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
index 8574886e3d77a..dda01f746845b 100644
--- a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
+++ b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
@@ -135,7 +135,7 @@ static_assert(test(std::ranges::search, a, a));
static_assert(test(std::ranges::search_n, a, 10, 42));
static_assert(test(std::ranges::set_
diff erence, a, a, a));
static_assert(test(std::ranges::set_intersection, a, a, a));
-//static_assert(test(std::ranges::set_symmetric_
diff erence, a, a, a));
+static_assert(test(std::ranges::set_symmetric_
diff erence, a, a, a));
//static_assert(test(std::ranges::set_union, a, a, a));
//static_assert(test(std::ranges::shuffle, a, g));
static_assert(test(std::ranges::sort, a));
More information about the libcxx-commits
mailing list