Google Git
Sign in
chromium / external / github.com / llvm / llvm-project.git / 065202f3ca9d32e32a1d9b2995e779ced64950b2 / . / libcxx / include / algorithm
blob: 88c7665d712b3ac09e4d973753eb548de92bcbf4 [file] [log] [blame]
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1// -*- C++ -*-
Louis Dionneeb8650a2021-11-17 21:25:01[diff] [blame]2//===----------------------------------------------------------------------===//
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]3//
Chandler Carruth57b08b02019-01-19 10:56:40[diff] [blame]4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_ALGORITHM
11#define _LIBCPP_ALGORITHM
12
13/*
14 algorithm synopsis
15
16#include <initializer_list>
17
18namespace std
19{
20
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]21namespace ranges {
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]22
23 // [algorithms.results], algorithm result types
Nikolas Klauser1e77b392022-02-11 16:01:58[diff] [blame]24 template <class I, class F>
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]25 struct in_fun_result; // since C++20
Nikolas Klauser1e77b392022-02-11 16:01:58[diff] [blame]26
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]27 template <class I1, class I2>
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]28 struct in_in_result; // since C++20
Nikolas Klauserf3514af2022-01-25 10:21:47[diff] [blame]29
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]30 template <class I, class O>
31 struct in_out_result; // since C++20
32
Nikolas Klauserf3514af2022-01-25 10:21:47[diff] [blame]33 template <class I1, class I2, class O>
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]34 struct in_in_out_result; // since C++20
Nikolas Klauser610979b2022-02-03 01:17:03[diff] [blame]35
36 template <class I, class O1, class O2>
37 struct in_out_out_result; // since C++20
Nikolas Klauser1e77b392022-02-11 16:01:58[diff] [blame]38
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]39 template <class I1, class I2>
40 struct min_max_result; // since C++20
41
Nikolas Klauser68f41312022-02-21 22:07:02[diff] [blame]42 template <class I>
43 struct in_found_result; // since C++20
44
Nikolas Klauser3b470d12022-02-11 12:11:57[diff] [blame]45 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
46 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> // since C++20
47 constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
48
49 template<forward_range R, class Proj = identity,
50 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // since C++20
51 constexpr borrowed_iterator_t<R> min_element(R&& r, Comp comp = {}, Proj proj = {});
Nikolas Klauserc2cd15a2022-03-08 22:12:35[diff] [blame]52
Nikolas Klauser40f7fca32022-05-22 11:43:37[diff] [blame]53 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
54 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
55 constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
56
57 template<forward_range R, class Proj = identity,
58 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
59 constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
60
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]61 template<class I1, class I2>
62 using mismatch_result = in_in_result<I1, I2>;
63
Nikolas Klauserc2cd15a2022-03-08 22:12:35[diff] [blame]64 template <input_iterator I1, sentinel_for<_I1> S1, input_iterator I2, sentinel_for<_I2> S2,
65 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
66 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
67 constexpr mismatch_result<_I1, _I2>
68 mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
69
70 template <input_range R1, input_range R2,
71 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
72 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
73 constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
74 mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
Nikolas Klauseree0f8c42022-03-12 00:45:35[diff] [blame]75
Nikolas Klauseree0f8c42022-03-12 00:45:35[diff] [blame]76 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
77 constexpr I find(I first, S last, const T& value, Proj proj = {}); // since C++20
78
79 template<input_range R, class T, class Proj = identity>
80 requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
81 constexpr borrowed_iterator_t<R>
82 find(R&& r, const T& value, Proj proj = {}); // since C++20
83
84 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
85 indirect_unary_predicate<projected<I, Proj>> Pred>
86 constexpr I find_if(I first, S last, Pred pred, Proj proj = {}); // since C++20
87
88 template<input_range R, class Proj = identity,
89 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
90 constexpr borrowed_iterator_t<R>
91 find_if(R&& r, Pred pred, Proj proj = {}); // since C++20
92
93 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
94 indirect_unary_predicate<projected<I, Proj>> Pred>
95 constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {}); // since C++20
96
97 template<input_range R, class Proj = identity,
98 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
99 constexpr borrowed_iterator_t<R>
100 find_if_not(R&& r, Pred pred, Proj proj = {}); // since C++20
Nikolas Klauserf83d8332022-03-18 01:57:08[diff] [blame]101
Nikolas Klausere476df52022-04-03 07:17:01[diff] [blame]102 template<class T, class Proj = identity,
103 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
104 constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauserf83d8332022-03-18 01:57:08[diff] [blame]105
Nikolas Klausere476df52022-04-03 07:17:01[diff] [blame]106 template<copyable T, class Proj = identity,
107 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
108 constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauserf83d8332022-03-18 01:57:08[diff] [blame]109
110 template<input_range R, class Proj = identity,
111 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
112 requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
113 constexpr range_value_t<R>
114 min(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klausere476df52022-04-03 07:17:01[diff] [blame]115
116 template<class T, class Proj = identity,
117 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
118 constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
119
120 template<copyable T, class Proj = identity,
121 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
122 constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20
123
124 template<input_range R, class Proj = identity,
125 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
126 requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
127 constexpr range_value_t<R>
128 max(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauser3ba85482022-04-05 09:05:36[diff] [blame]129
130 template<class I, class O>
131 using unary_transform_result = in_out_result<I, O>; // since C++20
132
133 template<class I1, class I2, class O>
134 using binary_transform_result = in_in_out_result<I1, I2, O>; // since C++20
135
136 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
137 copy_constructible F, class Proj = identity>
138 requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
139 constexpr ranges::unary_transform_result<I, O>
140 transform(I first1, S last1, O result, F op, Proj proj = {}); // since C++20
141
142 template<input_range R, weakly_incrementable O, copy_constructible F,
143 class Proj = identity>
144 requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
145 constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
146 transform(R&& r, O result, F op, Proj proj = {}); // since C++20
147
148 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
149 weakly_incrementable O, copy_constructible F, class Proj1 = identity,
150 class Proj2 = identity>
151 requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
152 projected<I2, Proj2>>>
153 constexpr ranges::binary_transform_result<I1, I2, O>
154 transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
155 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
156
157 template<input_range R1, input_range R2, weakly_incrementable O,
158 copy_constructible F, class Proj1 = identity, class Proj2 = identity>
159 requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
160 projected<iterator_t<R2>, Proj2>>>
161 constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
162 transform(R1&& r1, R2&& r2, O result,
163 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauser1306b102022-04-07 11:02:02[diff] [blame]164
165 template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
166 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
167 constexpr iter_difference_t<I>
168 count(I first, S last, const T& value, Proj proj = {}); // since C++20
169
170 template<input_range R, class T, class Proj = identity>
171 requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
172 constexpr range_difference_t<R>
173 count(R&& r, const T& value, Proj proj = {}); // since C++20
174
175 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
176 indirect_unary_predicate<projected<I, Proj>> Pred>
177 constexpr iter_difference_t<I>
178 count_if(I first, S last, Pred pred, Proj proj = {}); // since C++20
179
180 template<input_range R, class Proj = identity,
181 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
182 constexpr range_difference_t<R>
183 count_if(R&& r, Pred pred, Proj proj = {}); // since C++20
Nikolas Klauser58d9ab72022-04-13 20:59:09[diff] [blame]184
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]185 template<class T>
186 using minmax_result = min_max_result<T>;
187
Nikolas Klauser58d9ab72022-04-13 20:59:09[diff] [blame]188 template<class T, class Proj = identity,
189 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
190 constexpr ranges::minmax_result<const T&>
191 minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
192
193 template<copyable T, class Proj = identity,
194 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
195 constexpr ranges::minmax_result<T>
196 minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20
197
198 template<input_range R, class Proj = identity,
199 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
200 requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
201 constexpr ranges::minmax_result<range_value_t<R>>
202 minmax(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
203
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]204 template<class I>
205 using minmax_element_result = min_max_result<I>;
206
Nikolas Klauser58d9ab72022-04-13 20:59:09[diff] [blame]207 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
208 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
209 constexpr ranges::minmax_element_result<I>
210 minmax_element(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
211
212 template<forward_range R, class Proj = identity,
213 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
214 constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
215 minmax_element(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauser1d837502022-04-15 11:43:40[diff] [blame]216
217 template<class I, class O>
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]218 using copy_result = in_out_result<I, O>; // since C++20
Nikolas Klauser1d837502022-04-15 11:43:40[diff] [blame]219
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]220 template<class I, class O>
221 using copy_n_result = in_out_result<I, O>; // since C++20
Nikolas Klauser1d837502022-04-15 11:43:40[diff] [blame]222
223 template<class I, class O>
224 using copy_if_result = in_out_result<I, O>; // since C++20
225
226 template<class I1, class I2>
227 using copy_backward_result = in_out_result<I1, I2>; // since C++20
228
229 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
230 requires indirectly_copyable<I, O>
231 constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result); // since C++20
232
233 template<input_range R, weakly_incrementable O>
234 requires indirectly_copyable<iterator_t<R>, O>
235 constexpr ranges::copy_result<borrowed_iterator_t<R>, O> ranges::copy(R&& r, O result); // since C++20
236
237 template<input_iterator I, weakly_incrementable O>
238 requires indirectly_copyable<I, O>
239 constexpr ranges::copy_n_result<I, O>
240 ranges::copy_n(I first, iter_difference_t<I> n, O result); // since C++20
241
242 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
243 indirect_unary_predicate<projected<I, Proj>> Pred>
244 requires indirectly_copyable<I, O>
245 constexpr ranges::copy_if_result<I, O>
246 ranges::copy_if(I first, S last, O result, Pred pred, Proj proj = {}); // since C++20
247
248 template<input_range R, weakly_incrementable O, class Proj = identity,
249 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
250 requires indirectly_copyable<iterator_t<R>, O>
251 constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
252 ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {}); // since C++20
253
254 template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
255 requires indirectly_copyable<I1, I2>
256 constexpr ranges::copy_backward_result<I1, I2>
257 ranges::copy_backward(I1 first, S1 last, I2 result); // since C++20
258
259 template<bidirectional_range R, bidirectional_iterator I>
260 requires indirectly_copyable<iterator_t<R>, I>
261 constexpr ranges::copy_backward_result<borrowed_iterator_t<R>, I>
262 ranges::copy_backward(R&& r, I result); // since C++20
Nikolas Klauser80045e92022-05-04 18:27:07[diff] [blame]263
264 template<class I, class F>
265 using for_each_result = in_fun_result<I, F>; // since C++20
266
267 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
268 indirectly_unary_invocable<projected<I, Proj>> Fun>
269 constexpr ranges::for_each_result<I, Fun>
270 ranges::for_each(I first, S last, Fun f, Proj proj = {}); // since C++20
271
272 template<input_range R, class Proj = identity,
273 indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
274 constexpr ranges::for_each_result<borrowed_iterator_t<R>, Fun>
275 ranges::for_each(R&& r, Fun f, Proj proj = {}); // since C++20
276
277 template<input_iterator I, class Proj = identity,
278 indirectly_unary_invocable<projected<I, Proj>> Fun>
279 constexpr ranges::for_each_n_result<I, Fun>
280 ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {}); // since C++20
Nikolas Klauser37ba1b92022-05-04 12:19:09[diff] [blame]281
282 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
283 indirect_unary_predicate<projected<I, Proj>> Pred>
284 constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {}); // since C++20
285
286 template<input_range R, class Proj = identity,
287 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
288 constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {}); // since C++20
289
Konstantin Varlamovc945bd02022-07-08 20:46:27[diff] [blame]290 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
291 class Proj = identity>
292 requires sortable<I, Comp, Proj>
293 constexpr I
294 ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
295
296 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
297 requires sortable<iterator_t<R>, Comp, Proj>
298 constexpr borrowed_iterator_t<R>
299 ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
300
301 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
302 class Proj = identity>
303 requires sortable<I, Comp, Proj>
304 constexpr I
305 ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
306
307 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
308 requires sortable<iterator_t<R>, Comp, Proj>
309 constexpr borrowed_iterator_t<R>
310 ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
311
312 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
313 class Proj = identity>
314 requires sortable<I, Comp, Proj>
315 constexpr I
316 ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
317
318 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
319 requires sortable<iterator_t<R>, Comp, Proj>
320 constexpr borrowed_iterator_t<R>
321 ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
322
323 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
324 class Proj = identity>
325 requires sortable<I, Comp, Proj>
326 constexpr I
327 ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
328
329 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
330 requires sortable<iterator_t<R>, Comp, Proj>
331 constexpr borrowed_iterator_t<R>
332 ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
333
Nikolas Klauser1d1a1912022-05-24 08:32:50[diff] [blame]334 template<bidirectional_iterator I, sentinel_for<I> S>
335 requires permutable<I>
336 constexpr I ranges::reverse(I first, S last); // since C++20
337
338 template<bidirectional_range R>
339 requires permutable<iterator_t<R>>
340 constexpr borrowed_iterator_t<R> ranges::reverse(R&& r); // since C++20
341
Konstantin Varlamovff3989e2022-06-16 22:20:53[diff] [blame]342 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
343 class Proj = identity>
344 requires sortable<I, Comp, Proj>
345 constexpr I
Konstantin Varlamov94c7b892022-07-01 23:34:08[diff] [blame]346 ranges::sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
Konstantin Varlamovff3989e2022-06-16 22:20:53[diff] [blame]347
348 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
349 requires sortable<iterator_t<R>, Comp, Proj>
350 constexpr borrowed_iterator_t<R>
Konstantin Varlamov94c7b892022-07-01 23:34:08[diff] [blame]351 ranges::sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
352
353 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
354 class Proj = identity>
355 requires sortable<I, Comp, Proj>
356 I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
357
358 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
359 requires sortable<iterator_t<R>, Comp, Proj>
360 borrowed_iterator_t<R>
361 ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Konstantin Varlamovff3989e2022-06-16 22:20:53[diff] [blame]362
varconst5dd19ad2022-07-20 03:10:02[diff] [blame]363 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
364 class Proj = identity>
365 requires sortable<I, Comp, Proj>
366 constexpr I
367 ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {}); // since C++20
368
369 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
370 requires sortable<iterator_t<R>, Comp, Proj>
371 constexpr borrowed_iterator_t<R>
372 ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {}); // since C++20
373
Nikolas Klauser7af89a32022-05-21 16:26:29[diff] [blame]374 template<class T, output_iterator<const T&> O, sentinel_for<O> S>
375 constexpr O ranges::fill(O first, S last, const T& value); // since C++20
376
377 template<class T, output_range<const T&> R>
378 constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value); // since C++20
379
380 template<class T, output_iterator<const T&> O>
381 constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value); // since C++20
Nikolas Klauser569d6632022-05-25 09:09:43[diff] [blame]382
383 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
384 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
385 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
386 constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
387 Pred pred = {},
388 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
389
390 template<input_range R1, input_range R2, class Pred = ranges::equal_to,
391 class Proj1 = identity, class Proj2 = identity>
392 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
393 constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
394 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
395
Nikolas Klauser0e3dc1a2022-05-26 14:42:46[diff] [blame]396 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
397 indirect_unary_predicate<projected<I, Proj>> Pred>
398 constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
399
400 template<input_range R, class Proj = identity,
401 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
402 constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {}); // since C++20
403
404 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
405 indirect_unary_predicate<projected<I, Proj>> Pred>
406 constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
407
408 template<input_range R, class Proj = identity,
409 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
410 constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {}); // since C++20
411
412 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
413 indirect_unary_predicate<projected<I, Proj>> Pred>
414 constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
415
416 template<input_range R, class Proj = identity,
417 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
418 constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {}); // since C++20
419
Nikolas Klauser11e3ad22022-05-26 14:08:55[diff] [blame]420 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
421 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
422 constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
423
424 template<forward_range R, class Proj = identity,
425 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
426 constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
427
428 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
429 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
430 constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
431
432 template<forward_range R, class Proj = identity,
433 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
434 constexpr borrowed_iterator_t<R>
435 ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]436
Konstantin Varlamov23c73282022-07-08 03:35:51[diff] [blame]437 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
438 class Proj = identity>
439 requires sortable<I, Comp, Proj>
440 constexpr I
441 ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {}); // since C++20
442
443 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
444 requires sortable<iterator_t<R>, Comp, Proj>
445 constexpr borrowed_iterator_t<R>
446 ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {}); // since C++20
447
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]448 template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
449 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
450 constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
451
452 template<forward_range R, class T, class Proj = identity,
453 indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
454 ranges::less>
455 constexpr borrowed_iterator_t<R>
456 upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
457
458 template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
459 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
460 constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
461 Proj proj = {}); // since C++20
462 template<forward_range R, class T, class Proj = identity,
463 indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
464 ranges::less>
465 constexpr borrowed_iterator_t<R>
466 lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
467
468 template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
469 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
470 constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
471 Proj proj = {}); // since C++20
Nikolas Klauserb79b2b62022-06-06 11:57:34[diff] [blame]472
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]473 template<forward_range R, class T, class Proj = identity,
474 indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
475 ranges::less>
476 constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
477 Proj proj = {}); // since C++20
Konstantin Varlamov8ed702b2022-07-19 04:05:51[diff] [blame]478
479 template<permutable I, sentinel_for<I> S, class Proj = identity,
480 indirect_unary_predicate<projected<I, Proj>> Pred>
481 constexpr subrange<I>
482 partition(I first, S last, Pred pred, Proj proj = {}); // Since C++20
483
484 template<forward_range R, class Proj = identity,
485 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
486 requires permutable<iterator_t<R>>
487 constexpr borrowed_subrange_t<R>
488 partition(R&& r, Pred pred, Proj proj = {}); // Since C++20
489
490 template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
491 indirect_unary_predicate<projected<I, Proj>> Pred>
492 requires permutable<I>
493 subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {}); // Since C++20
494
495 template<bidirectional_range R, class Proj = identity,
496 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
497 requires permutable<iterator_t<R>>
498 borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {}); // Since C++20
499
Nikolas Klauserb79b2b62022-06-06 11:57:34[diff] [blame]500 template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
501 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
502 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
503 constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
504 Pred pred = {},
505 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
506
507 template<input_range R1, forward_range R2,
508 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
509 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
510 constexpr borrowed_iterator_t<R1>
511 ranges::find_first_of(R1&& r1, R2&& r2,
512 Pred pred = {},
513 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]514
Nikolas Klauser916e9052022-06-08 10:14:12[diff] [blame]515 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
516 indirect_binary_predicate<projected<I, Proj>,
517 projected<I, Proj>> Pred = ranges::equal_to>
518 constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {}); // since C+20
519
520 template<forward_range R, class Proj = identity,
521 indirect_binary_predicate<projected<iterator_t<R>, Proj>,
522 projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
523 constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {}); // since C++20
524
Nikolas Klauserff6d5de2022-06-07 07:42:10[diff] [blame]525 template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
526 requires indirectly_writable<I, const T2&> &&
527 indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
528 constexpr I
529 ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20
530
531 template<input_range R, class T1, class T2, class Proj = identity>
532 requires indirectly_writable<iterator_t<R>, const T2&> &&
533 indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
534 constexpr borrowed_iterator_t<R>
535 ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20
536
537 template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
538 indirect_unary_predicate<projected<I, Proj>> Pred>
539 requires indirectly_writable<I, const T&>
540 constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {}); // since C++20
541
542 template<input_range R, class T, class Proj = identity,
543 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
544 requires indirectly_writable<iterator_t<R>, const T&>
545 constexpr borrowed_iterator_t<R>
546 ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {}); // since C++20
547
Nikolas Klauserafd5a4f2022-06-15 14:24:43[diff] [blame]548 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
549 class Proj1 = identity, class Proj2 = identity,
550 indirect_strict_weak_order<projected<I1, Proj1>,
551 projected<I2, Proj2>> Comp = ranges::less>
552 constexpr bool
553 ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
554 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
555
556 template<input_range R1, input_range R2, class Proj1 = identity,
557 class Proj2 = identity,
558 indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
559 projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
560 constexpr bool
561 ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
562 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
563
Nikolas Klauser2c3bbac2022-06-23 10:23:41[diff] [blame]564 template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
565 requires indirectly_movable<I1, I2>
566 constexpr ranges::move_backward_result<I1, I2>
567 ranges::move_backward(I1 first, S1 last, I2 result); // since C++20
568
569 template<bidirectional_range R, bidirectional_iterator I>
570 requires indirectly_movable<iterator_t<R>, I>
571 constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
572 ranges::move_backward(R&& r, I result); // since C++20
573
574 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
575 requires indirectly_movable<I, O>
576 constexpr ranges::move_result<I, O>
577 ranges::move(I first, S last, O result); // since C++20
578
579 template<input_range R, weakly_incrementable O>
580 requires indirectly_movable<iterator_t<R>, O>
581 constexpr ranges::move_result<borrowed_iterator_t<R>, O>
582 ranges::move(R&& r, O result); // since C++20
583
Konstantin Varlamov065202f2022-07-20 08:57:13[diff] [blame^]584 template<class I, class O1, class O2>
585 using partition_copy_result = in_out_out_result<I, O1, O2>; // since C++20
586
587 template<input_iterator I, sentinel_for<I> S,
588 weakly_incrementable O1, weakly_incrementable O2,
589 class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
590 requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
591 constexpr partition_copy_result<I, O1, O2>
592 partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,
593 Proj proj = {}); // Since C++20
594
595 template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
596 class Proj = identity,
597 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
598 requires indirectly_copyable<iterator_t<R>, O1> &&
599 indirectly_copyable<iterator_t<R>, O2>
600 constexpr partition_copy_result<borrowed_iterator_t<R>, O1, O2>
601 partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {}); // Since C++20
602
603 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
604 indirect_unary_predicate<projected<I, Proj>> Pred>
605 constexpr I partition_point(I first, S last, Pred pred, Proj proj = {}); // Since C++20
606
607 template<forward_range R, class Proj = identity,
608 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
609 constexpr borrowed_iterator_t<R>
610 partition_point(R&& r, Pred pred, Proj proj = {}); // Since C++20
611
Hui Xie25607d12022-06-26 15:13:43[diff] [blame]612 template<class I1, class I2, class O>
613 using merge_result = in_in_out_result<I1, I2, O>; // since C++20
614
615 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
616 weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
617 class Proj2 = identity>
618 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
619 constexpr merge_result<I1, I2, O>
620 merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
621 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
622
623 template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
624 class Proj1 = identity, class Proj2 = identity>
625 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
626 constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
627 merge(R1&& r1, R2&& r2, O result,
628 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauser2c3bbac2022-06-23 10:23:41[diff] [blame]629
Nikolas Klauserf8cbe3cdf2022-07-06 12:03:00[diff] [blame]630 template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
631 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
632 constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {}); // since C++20
633
634 template<forward_range R, class T, class Proj = identity>
635 requires permutable<iterator_t<R>> &&
636 indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
637 constexpr borrowed_subrange_t<R>
638 ranges::remove(R&& r, const T& value, Proj proj = {}); // since C++20
639
640 template<permutable I, sentinel_for<I> S, class Proj = identity,
641 indirect_unary_predicate<projected<I, Proj>> Pred>
642 constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {}); // since C++20
643
644 template<forward_range R, class Proj = identity,
645 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
646 requires permutable<iterator_t<R>>
647 constexpr borrowed_subrange_t<R>
648 ranges::remove_if(R&& r, Pred pred, Proj proj = {}); // since C++20
Nikolas Klauser7d426a32022-07-11 15:07:35[diff] [blame]649
Hui Xie1cdec6c2022-06-26 15:13:43[diff] [blame]650 template<class I, class O>
Nikolas Klauser7d426a32022-07-11 15:07:35[diff] [blame]651 using set_difference_result = in_out_result<I, O>; // since C++20
Hui Xie1cdec6c2022-06-26 15:13:43[diff] [blame]652
653 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
654 weakly_incrementable O, class Comp = ranges::less,
655 class Proj1 = identity, class Proj2 = identity>
656 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
657 constexpr set_difference_result<I1, O>
658 set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
659 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
660
661 template<input_range R1, input_range R2, weakly_incrementable O,
662 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
663 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
664 constexpr set_difference_result<borrowed_iterator_t<R1>, O>
665 set_difference(R1&& r1, R2&& r2, O result,
666 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauserf8cbe3cdf2022-07-06 12:03:00[diff] [blame]667
Hui Xie96b674f2022-07-08 14:21:40[diff] [blame]668 template<class I1, class I2, class O>
669 using set_intersection_result = in_in_out_result<I1, I2, O>; // since C++20
670
671 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
672 weakly_incrementable O, class Comp = ranges::less,
673 class Proj1 = identity, class Proj2 = identity>
674 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
675 constexpr set_intersection_result<I1, I2, O>
676 set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,
677 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
678
679 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
680 weakly_incrementable O, class Comp = ranges::less,
681 class Proj1 = identity, class Proj2 = identity>
682 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
683 constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
684 set_intersection(R1&& r1, R2&& r2, O result,
685 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
686
Nikolas Klauser7d426a32022-07-11 15:07:35[diff] [blame]687 template <class _InIter, class _OutIter>
688 using reverse_copy_result = in_out_result<_InIter, _OutIter>; // since C++20
689
690 template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
691 requires indirectly_copyable<I, O>
692 constexpr ranges::reverse_copy_result<I, O>
693 ranges::reverse_copy(I first, S last, O result); // since C++20
694
695 template<bidirectional_range R, weakly_incrementable O>
696 requires indirectly_copyable<iterator_t<R>, O>
697 constexpr ranges::reverse_copy_result<borrowed_iterator_t<R>, O>
698 ranges::reverse_copy(R&& r, O result); // since C++20
699
700 template <class _InIter, class _OutIter>
701 using rotate_copy_result = in_out_result<_InIter, _OutIter>; // since C++20
702
703 template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
704 requires indirectly_copyable<I, O>
705 constexpr ranges::rotate_copy_result<I, O>
706 ranges::rotate_copy(I first, I middle, S last, O result); // since C++20
707
708 template<forward_range R, weakly_incrementable O>
709 requires indirectly_copyable<iterator_t<R>, O>
710 constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
711 ranges::rotate_copy(R&& r, iterator_t<R> middle, O result); // since C++20
712
Nikolas Klauser101d1e92022-07-13 16:07:26[diff] [blame]713 template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
714 sentinel_for<I2> S2, class Pred = ranges::equal_to,
715 class Proj1 = identity, class Proj2 = identity>
716 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
717 constexpr subrange<I1>
718 ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
719 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
720
721 template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
722 class Proj1 = identity, class Proj2 = identity>
723 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
724 constexpr borrowed_subrange_t<R1>
725 ranges::search(R1&& r1, R2&& r2, Pred pred = {},
726 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
727
728 template<forward_iterator I, sentinel_for<I> S, class T,
729 class Pred = ranges::equal_to, class Proj = identity>
730 requires indirectly_comparable<I, const T*, Pred, Proj>
731 constexpr subrange<I>
732 ranges::search_n(I first, S last, iter_difference_t<I> count,
733 const T& value, Pred pred = {}, Proj proj = {}); // since C++20
734
735 template<forward_range R, class T, class Pred = ranges::equal_to,
736 class Proj = identity>
737 requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
738 constexpr borrowed_subrange_t<R>
739 ranges::search_n(R&& r, range_difference_t<R> count,
740 const T& value, Pred pred = {}, Proj proj = {}); // since C++20
741
742 template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
743 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
744 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
745 constexpr subrange<I1>
746 ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
747 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
748
749 template<forward_range R1, forward_range R2,
750 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
751 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
752 constexpr borrowed_subrange_t<R1>
753 ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
754 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
755
Hui Xiea5c06382022-07-11 22:39:59[diff] [blame]756 template<class I1, class I2, class O>
757 using set_symmetric_difference_result = in_in_out_result<I1, I2, O>; // since C++20
758
759 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
760 weakly_incrementable O, class Comp = ranges::less,
761 class Proj1 = identity, class Proj2 = identity>
762 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
763 constexpr set_symmetric_difference_result<I1, I2, O>
764 set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
765 Comp comp = {}, Proj1 proj1 = {},
766 Proj2 proj2 = {}); // since C++20
767
768 template<input_range R1, input_range R2, weakly_incrementable O,
769 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
770 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
771 constexpr set_symmetric_difference_result<borrowed_iterator_t<R1>,
772 borrowed_iterator_t<R2>, O>
773 set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
774 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
775
Hui Xie3151b952022-07-13 16:20:22[diff] [blame]776 template<class I1, class I2, class O>
777 using set_union_result = in_in_out_result<I1, I2, O>; // since C++20
778
779 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
780 weakly_incrementable O, class Comp = ranges::less,
781 class Proj1 = identity, class Proj2 = identity>
782 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
783 constexpr set_union_result<I1, I2, O>
784 set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
785 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
786
787 template<input_range R1, input_range R2, weakly_incrementable O,
788 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
789 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
790 constexpr set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
791 set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
792 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]793}
794
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]795 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]796 all_of(InputIterator first, InputIterator last, Predicate pred);
797
798template <class InputIterator, class Predicate>
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]799 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]800 any_of(InputIterator first, InputIterator last, Predicate pred);
801
802template <class InputIterator, class Predicate>
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]803 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]804 none_of(InputIterator first, InputIterator last, Predicate pred);
805
806template <class InputIterator, class Function>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]807 constexpr Function // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]808 for_each(InputIterator first, InputIterator last, Function f);
809
Marshall Clowd5c65ff2017-05-25 02:29:54[diff] [blame]810template<class InputIterator, class Size, class Function>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]811 constexpr InputIterator // constexpr in C++20
812 for_each_n(InputIterator first, Size n, Function f); // C++17
Marshall Clowd5c65ff2017-05-25 02:29:54[diff] [blame]813
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]814template <class InputIterator, class T>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]815 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]816 find(InputIterator first, InputIterator last, const T& value);
817
818template <class InputIterator, class Predicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]819 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]820 find_if(InputIterator first, InputIterator last, Predicate pred);
821
822template<class InputIterator, class Predicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]823 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]824 find_if_not(InputIterator first, InputIterator last, Predicate pred);
825
826template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]827 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]828 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
829 ForwardIterator2 first2, ForwardIterator2 last2);
830
831template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]832 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]833 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
834 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
835
836template <class ForwardIterator1, class ForwardIterator2>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]837 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]838 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
839 ForwardIterator2 first2, ForwardIterator2 last2);
840
841template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]842 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]843 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
844 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
845
846template <class ForwardIterator>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]847 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]848 adjacent_find(ForwardIterator first, ForwardIterator last);
849
850template <class ForwardIterator, class BinaryPredicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]851 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]852 adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
853
854template <class InputIterator, class T>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]855 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]856 count(InputIterator first, InputIterator last, const T& value);
857
858template <class InputIterator, class Predicate>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]859 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]860 count_if(InputIterator first, InputIterator last, Predicate pred);
861
862template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]863 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]864 mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
865
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]866template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]867 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Aditya Kumar331fb802016-08-25 11:52:38[diff] [blame]868 mismatch(InputIterator1 first1, InputIterator1 last1,
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]869 InputIterator2 first2, InputIterator2 last2); // **C++14**
870
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]871template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]872 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]873 mismatch(InputIterator1 first1, InputIterator1 last1,
874 InputIterator2 first2, BinaryPredicate pred);
875
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]876template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]877 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]878 mismatch(InputIterator1 first1, InputIterator1 last1,
879 InputIterator2 first2, InputIterator2 last2,
880 BinaryPredicate pred); // **C++14**
881
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]882template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]883 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]884 equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
885
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]886template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]887 constexpr bool // constexpr in C++20
Aditya Kumar331fb802016-08-25 11:52:38[diff] [blame]888 equal(InputIterator1 first1, InputIterator1 last1,
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]889 InputIterator2 first2, InputIterator2 last2); // **C++14**
890
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]891template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]892 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]893 equal(InputIterator1 first1, InputIterator1 last1,
894 InputIterator2 first2, BinaryPredicate pred);
895
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]896template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]897 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]898 equal(InputIterator1 first1, InputIterator1 last1,
899 InputIterator2 first2, InputIterator2 last2,
900 BinaryPredicate pred); // **C++14**
901
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]902template<class ForwardIterator1, class ForwardIterator2>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]903 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]904 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
905 ForwardIterator2 first2);
906
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]907template<class ForwardIterator1, class ForwardIterator2>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]908 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]909 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
910 ForwardIterator2 first2, ForwardIterator2 last2); // **C++14**
911
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]912template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]913 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]914 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
915 ForwardIterator2 first2, BinaryPredicate pred);
916
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]917template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]918 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]919 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
920 ForwardIterator2 first2, ForwardIterator2 last2,
921 BinaryPredicate pred); // **C++14**
922
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]923template <class ForwardIterator1, class ForwardIterator2>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]924 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]925 search(ForwardIterator1 first1, ForwardIterator1 last1,
926 ForwardIterator2 first2, ForwardIterator2 last2);
927
928template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]929 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]930 search(ForwardIterator1 first1, ForwardIterator1 last1,
931 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
932
933template <class ForwardIterator, class Size, class T>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]934 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]935 search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
936
937template <class ForwardIterator, class Size, class T, class BinaryPredicate>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]938 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]939 search_n(ForwardIterator first, ForwardIterator last,
940 Size count, const T& value, BinaryPredicate pred);
941
942template <class InputIterator, class OutputIterator>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]943 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]944 copy(InputIterator first, InputIterator last, OutputIterator result);
945
946template<class InputIterator, class OutputIterator, class Predicate>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]947 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]948 copy_if(InputIterator first, InputIterator last,
949 OutputIterator result, Predicate pred);
950
951template<class InputIterator, class Size, class OutputIterator>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]952 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]953 copy_n(InputIterator first, Size n, OutputIterator result);
954
955template <class BidirectionalIterator1, class BidirectionalIterator2>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]956 constexpr BidirectionalIterator2 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]957 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
958 BidirectionalIterator2 result);
959
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]960// [alg.move], move
961template<class InputIterator, class OutputIterator>
962 constexpr OutputIterator move(InputIterator first, InputIterator last,
963 OutputIterator result);
964
965template<class BidirectionalIterator1, class BidirectionalIterator2>
966 constexpr BidirectionalIterator2
967 move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
968 BidirectionalIterator2 result);
969
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]970template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]971 constexpr ForwardIterator2 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]972 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
973
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]974namespace ranges {
975 template<class I1, class I2>
976 using swap_ranges_result = in_in_result<I1, I2>;
977
Nikolas Klauser9d905312022-02-10 12:33:03[diff] [blame]978template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
979 requires indirectly_swappable<I1, I2>
980 constexpr ranges::swap_ranges_result<I1, I2>
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]981 swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
Nikolas Klauser9d905312022-02-10 12:33:03[diff] [blame]982
983template<input_range R1, input_range R2>
984 requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
985 constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]986 swap_ranges(R1&& r1, R2&& r2);
987}
Nikolas Klauser9d905312022-02-10 12:33:03[diff] [blame]988
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]989template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]990 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]991 iter_swap(ForwardIterator1 a, ForwardIterator2 b);
992
993template <class InputIterator, class OutputIterator, class UnaryOperation>
Marshall Clow99894b62018-01-19 17:45:39[diff] [blame]994 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]995 transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
996
997template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
Marshall Clow99894b62018-01-19 17:45:39[diff] [blame]998 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]999 transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
1000 OutputIterator result, BinaryOperation binary_op);
1001
1002template <class ForwardIterator, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]1003 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1004 replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
1005
1006template <class ForwardIterator, class Predicate, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]1007 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1008 replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
1009
1010template <class InputIterator, class OutputIterator, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]1011 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1012 replace_copy(InputIterator first, InputIterator last, OutputIterator result,
1013 const T& old_value, const T& new_value);
1014
1015template <class InputIterator, class OutputIterator, class Predicate, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]1016 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1017 replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);
1018
1019template <class ForwardIterator, class T>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]1020 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1021 fill(ForwardIterator first, ForwardIterator last, const T& value);
1022
1023template <class OutputIterator, class Size, class T>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]1024 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1025 fill_n(OutputIterator first, Size n, const T& value);
1026
1027template <class ForwardIterator, class Generator>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]1028 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1029 generate(ForwardIterator first, ForwardIterator last, Generator gen);
1030
1031template <class OutputIterator, class Size, class Generator>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]1032 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1033 generate_n(OutputIterator first, Size n, Generator gen);
1034
1035template <class ForwardIterator, class T>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1036 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1037 remove(ForwardIterator first, ForwardIterator last, const T& value);
1038
1039template <class ForwardIterator, class Predicate>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1040 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1041 remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
1042
1043template <class InputIterator, class OutputIterator, class T>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1044 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1045 remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
1046
1047template <class InputIterator, class OutputIterator, class Predicate>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1048 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1049 remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
1050
1051template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1052 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1053 unique(ForwardIterator first, ForwardIterator last);
1054
1055template <class ForwardIterator, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1056 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1057 unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
1058
1059template <class InputIterator, class OutputIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1060 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1061 unique_copy(InputIterator first, InputIterator last, OutputIterator result);
1062
1063template <class InputIterator, class OutputIterator, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1064 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1065 unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);
1066
1067template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1068 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1069 reverse(BidirectionalIterator first, BidirectionalIterator last);
1070
1071template <class BidirectionalIterator, class OutputIterator>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1072 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1073 reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
1074
1075template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1076 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1077 rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
1078
1079template <class ForwardIterator, class OutputIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1080 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1081 rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
1082
1083template <class RandomAccessIterator>
1084 void
Marshall Clow0f37a412017-03-23 13:43:37[diff] [blame]1085 random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1086
1087template <class RandomAccessIterator, class RandomNumberGenerator>
1088 void
Marshall Clow06965c12014-03-03 06:14:19[diff] [blame]1089 random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
Marshall Clow0f37a412017-03-23 13:43:37[diff] [blame]1090 RandomNumberGenerator& rand); // deprecated in C++14, removed in C++17
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1091
Eric Fiseliere7154702016-08-28 22:14:37[diff] [blame]1092template<class PopulationIterator, class SampleIterator,
1093 class Distance, class UniformRandomBitGenerator>
1094 SampleIterator sample(PopulationIterator first, PopulationIterator last,
1095 SampleIterator out, Distance n,
1096 UniformRandomBitGenerator&& g); // C++17
1097
Howard Hinnantf9d540b2010-05-26 17:49:34[diff] [blame]1098template<class RandomAccessIterator, class UniformRandomNumberGenerator>
1099 void shuffle(RandomAccessIterator first, RandomAccessIterator last,
Howard Hinnantfb340102010-11-18 01:47:02[diff] [blame]1100 UniformRandomNumberGenerator&& g);
Howard Hinnantf9d540b2010-05-26 17:49:34[diff] [blame]1101
Arthur O'Dwyer3fbd3ea2020-12-26 06:39:03[diff] [blame]1102template<class ForwardIterator>
1103 constexpr ForwardIterator
1104 shift_left(ForwardIterator first, ForwardIterator last,
1105 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
1106
1107template<class ForwardIterator>
1108 constexpr ForwardIterator
1109 shift_right(ForwardIterator first, ForwardIterator last,
1110 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
1111
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1112template <class InputIterator, class Predicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1113 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1114 is_partitioned(InputIterator first, InputIterator last, Predicate pred);
1115
1116template <class ForwardIterator, class Predicate>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1117 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1118 partition(ForwardIterator first, ForwardIterator last, Predicate pred);
1119
1120template <class InputIterator, class OutputIterator1,
1121 class OutputIterator2, class Predicate>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]1122 constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1123 partition_copy(InputIterator first, InputIterator last,
1124 OutputIterator1 out_true, OutputIterator2 out_false,
1125 Predicate pred);
1126
1127template <class ForwardIterator, class Predicate>
1128 ForwardIterator
1129 stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
1130
1131template<class ForwardIterator, class Predicate>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1132 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1133 partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
1134
1135template <class ForwardIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1136 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1137 is_sorted(ForwardIterator first, ForwardIterator last);
1138
1139template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1140 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1141 is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
1142
1143template<class ForwardIterator>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]1144 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1145 is_sorted_until(ForwardIterator first, ForwardIterator last);
1146
1147template <class ForwardIterator, class Compare>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]1148 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1149 is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
1150
1151template <class RandomAccessIterator>
Arthur O'Dwyer493f1402020-12-20 20:21:42[diff] [blame]1152 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1153 sort(RandomAccessIterator first, RandomAccessIterator last);
1154
1155template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer493f1402020-12-20 20:21:42[diff] [blame]1156 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1157 sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1158
1159template <class RandomAccessIterator>
1160 void
1161 stable_sort(RandomAccessIterator first, RandomAccessIterator last);
1162
1163template <class RandomAccessIterator, class Compare>
1164 void
1165 stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1166
1167template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1168 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1169 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
1170
1171template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1172 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1173 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
1174
1175template <class InputIterator, class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1176 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1177 partial_sort_copy(InputIterator first, InputIterator last,
1178 RandomAccessIterator result_first, RandomAccessIterator result_last);
1179
1180template <class InputIterator, class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1181 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1182 partial_sort_copy(InputIterator first, InputIterator last,
1183 RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);
1184
1185template <class RandomAccessIterator>
Arthur O'Dwyer5d956562021-02-04 23:12:52[diff] [blame]1186 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1187 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
1188
1189template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5d956562021-02-04 23:12:52[diff] [blame]1190 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1191 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
1192
1193template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1194 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1195 lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
1196
1197template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1198 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1199 lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1200
1201template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1202 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1203 upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
1204
1205template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1206 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1207 upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1208
1209template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1210 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1211 equal_range(ForwardIterator first, ForwardIterator last, const T& value);
1212
1213template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1214 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1215 equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1216
1217template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1218 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1219 binary_search(ForwardIterator first, ForwardIterator last, const T& value);
1220
1221template <class ForwardIterator, class T, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1222 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1223 binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1224
1225template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1226 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1227 merge(InputIterator1 first1, InputIterator1 last1,
1228 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1229
1230template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1231 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1232 merge(InputIterator1 first1, InputIterator1 last1,
1233 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1234
1235template <class BidirectionalIterator>
1236 void
1237 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
1238
1239template <class BidirectionalIterator, class Compare>
1240 void
1241 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
1242
1243template <class InputIterator1, class InputIterator2>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1244 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1245 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
1246
1247template <class InputIterator1, class InputIterator2, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1248 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1249 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
1250
1251template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1252 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1253 set_union(InputIterator1 first1, InputIterator1 last1,
1254 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1255
1256template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1257 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1258 set_union(InputIterator1 first1, InputIterator1 last1,
1259 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1260
1261template <class InputIterator1, class InputIterator2, class OutputIterator>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1262 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1263 set_intersection(InputIterator1 first1, InputIterator1 last1,
1264 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1265
1266template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1267 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1268 set_intersection(InputIterator1 first1, InputIterator1 last1,
1269 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1270
1271template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1272 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1273 set_difference(InputIterator1 first1, InputIterator1 last1,
1274 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1275
1276template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1277 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1278 set_difference(InputIterator1 first1, InputIterator1 last1,
1279 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1280
1281template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1282 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1283 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
1284 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1285
1286template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1287 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1288 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
1289 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1290
1291template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1292 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1293 push_heap(RandomAccessIterator first, RandomAccessIterator last);
1294
1295template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1296 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1297 push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1298
1299template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1300 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1301 pop_heap(RandomAccessIterator first, RandomAccessIterator last);
1302
1303template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1304 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1305 pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1306
1307template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1308 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1309 make_heap(RandomAccessIterator first, RandomAccessIterator last);
1310
1311template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1312 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1313 make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1314
1315template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1316 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1317 sort_heap(RandomAccessIterator first, RandomAccessIterator last);
1318
1319template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1320 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1321 sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1322
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1323template <class RandomAccessIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1324 constexpr bool // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1325 is_heap(RandomAccessIterator first, RandomAccessiterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1326
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1327template <class RandomAccessIterator, class Compare>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1328 constexpr bool // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1329 is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1330
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1331template <class RandomAccessIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1332 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1333 is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1334
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1335template <class RandomAccessIterator, class Compare>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1336 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1337 is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1338
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1339template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1340 constexpr ForwardIterator // constexpr in C++14
1341 min_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1342
1343template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1344 constexpr ForwardIterator // constexpr in C++14
1345 min_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1346
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1347template <class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1348 constexpr const T& // constexpr in C++14
1349 min(const T& a, const T& b);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1350
1351template <class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1352 constexpr const T& // constexpr in C++14
1353 min(const T& a, const T& b, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1354
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1355template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1356 constexpr T // constexpr in C++14
1357 min(initializer_list<T> t);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1358
1359template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1360 constexpr T // constexpr in C++14
1361 min(initializer_list<T> t, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1362
Marshall Clow146c14a2016-03-07 22:43:49[diff] [blame]1363template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1364 constexpr const T& clamp(const T& v, const T& lo, const T& hi); // C++17
Marshall Clow146c14a2016-03-07 22:43:49[diff] [blame]1365
1366template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1367 constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp); // C++17
Marshall Clow146c14a2016-03-07 22:43:49[diff] [blame]1368
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1369template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1370 constexpr ForwardIterator // constexpr in C++14
1371 max_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1372
1373template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1374 constexpr ForwardIterator // constexpr in C++14
1375 max_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1376
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1377template <class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1378 constexpr const T& // constexpr in C++14
1379 max(const T& a, const T& b);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1380
1381template <class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1382 constexpr const T& // constexpr in C++14
1383 max(const T& a, const T& b, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1384
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1385template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1386 constexpr T // constexpr in C++14
1387 max(initializer_list<T> t);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1388
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1389template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1390 constexpr T // constexpr in C++14
1391 max(initializer_list<T> t, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1392
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1393template<class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1394 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
1395 minmax_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1396
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1397template<class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1398 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
1399 minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1400
1401template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1402 constexpr pair<const T&, const T&> // constexpr in C++14
1403 minmax(const T& a, const T& b);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1404
1405template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1406 constexpr pair<const T&, const T&> // constexpr in C++14
1407 minmax(const T& a, const T& b, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1408
1409template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1410 constexpr pair<T, T> // constexpr in C++14
1411 minmax(initializer_list<T> t);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1412
1413template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1414 constexpr pair<T, T> // constexpr in C++14
1415 minmax(initializer_list<T> t, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1416
1417template <class InputIterator1, class InputIterator2>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]1418 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1419 lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
1420
1421template <class InputIterator1, class InputIterator2, class Compare>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]1422 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1423 lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
1424 InputIterator2 first2, InputIterator2 last2, Compare comp);
1425
1426template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1427 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1428 next_permutation(BidirectionalIterator first, BidirectionalIterator last);
1429
1430template <class BidirectionalIterator, class Compare>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1431 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1432 next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
1433
1434template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1435 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1436 prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
1437
1438template <class BidirectionalIterator, class Compare>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1439 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1440 prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1441} // std
1442
1443*/
1444
Louis Dionne385cc252022-03-25 16:55:36[diff] [blame]1445#include <__assert> // all public C++ headers provide the assertion handler
Arthur O'Dwyerea2206d2022-02-04 18:09:30[diff] [blame]1446#include <__bits>
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1447#include <__config>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1448#include <__debug>
Howard Hinnanta1d07d52012-07-26 17:09:09[diff] [blame]1449#include <cstddef>
Arthur O'Dwyerbfbd73f2021-05-19 15:57:04[diff] [blame]1450#include <cstring>
Arthur O'Dwyerbfbd73f2021-05-19 15:57:04[diff] [blame]1451#include <memory>
1452#include <type_traits>
Marshall Clowf56972e2018-09-12 19:41:40[diff] [blame]1453#include <version>
Howard Hinnant5d1a7012013-08-14 18:00:20[diff] [blame]1454
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1455#include <__algorithm/adjacent_find.h>
1456#include <__algorithm/all_of.h>
1457#include <__algorithm/any_of.h>
1458#include <__algorithm/binary_search.h>
1459#include <__algorithm/clamp.h>
1460#include <__algorithm/comp.h>
1461#include <__algorithm/comp_ref_type.h>
1462#include <__algorithm/copy.h>
1463#include <__algorithm/copy_backward.h>
1464#include <__algorithm/copy_if.h>
1465#include <__algorithm/copy_n.h>
1466#include <__algorithm/count.h>
1467#include <__algorithm/count_if.h>
1468#include <__algorithm/equal.h>
1469#include <__algorithm/equal_range.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1470#include <__algorithm/fill.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]1471#include <__algorithm/fill_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1472#include <__algorithm/find.h>
1473#include <__algorithm/find_end.h>
1474#include <__algorithm/find_first_of.h>
1475#include <__algorithm/find_if.h>
1476#include <__algorithm/find_if_not.h>
1477#include <__algorithm/for_each.h>
1478#include <__algorithm/for_each_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1479#include <__algorithm/generate.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]1480#include <__algorithm/generate_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1481#include <__algorithm/half_positive.h>
Nikolas Klauser68f41312022-02-21 22:07:02[diff] [blame]1482#include <__algorithm/in_found_result.h>
Nikolas Klauser1e77b392022-02-11 16:01:58[diff] [blame]1483#include <__algorithm/in_fun_result.h>
Nikolas Klauserf3514af2022-01-25 10:21:47[diff] [blame]1484#include <__algorithm/in_in_out_result.h>
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]1485#include <__algorithm/in_in_result.h>
Nikolas Klauser610979b2022-02-03 01:17:03[diff] [blame]1486#include <__algorithm/in_out_out_result.h>
Konstantin Varlamov8d23b742022-01-11 06:49:37[diff] [blame]1487#include <__algorithm/in_out_result.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1488#include <__algorithm/includes.h>
1489#include <__algorithm/inplace_merge.h>
1490#include <__algorithm/is_heap.h>
1491#include <__algorithm/is_heap_until.h>
1492#include <__algorithm/is_partitioned.h>
1493#include <__algorithm/is_permutation.h>
1494#include <__algorithm/is_sorted.h>
1495#include <__algorithm/is_sorted_until.h>
Christopher Di Bella6adbc832021-06-05 02:47:47[diff] [blame]1496#include <__algorithm/iter_swap.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1497#include <__algorithm/lexicographical_compare.h>
1498#include <__algorithm/lower_bound.h>
1499#include <__algorithm/make_heap.h>
1500#include <__algorithm/max.h>
1501#include <__algorithm/max_element.h>
1502#include <__algorithm/merge.h>
1503#include <__algorithm/min.h>
1504#include <__algorithm/min_element.h>
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]1505#include <__algorithm/min_max_result.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1506#include <__algorithm/minmax.h>
1507#include <__algorithm/minmax_element.h>
1508#include <__algorithm/mismatch.h>
1509#include <__algorithm/move.h>
1510#include <__algorithm/move_backward.h>
1511#include <__algorithm/next_permutation.h>
1512#include <__algorithm/none_of.h>
1513#include <__algorithm/nth_element.h>
1514#include <__algorithm/partial_sort.h>
1515#include <__algorithm/partial_sort_copy.h>
1516#include <__algorithm/partition.h>
1517#include <__algorithm/partition_copy.h>
1518#include <__algorithm/partition_point.h>
1519#include <__algorithm/pop_heap.h>
1520#include <__algorithm/prev_permutation.h>
1521#include <__algorithm/push_heap.h>
Nikolas Klauser916e9052022-06-08 10:14:12[diff] [blame]1522#include <__algorithm/ranges_adjacent_find.h>
Nikolas Klauser0e3dc1a2022-05-26 14:42:46[diff] [blame]1523#include <__algorithm/ranges_all_of.h>
1524#include <__algorithm/ranges_any_of.h>
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]1525#include <__algorithm/ranges_binary_search.h>
Nikolas Klauser1d837502022-04-15 11:43:40[diff] [blame]1526#include <__algorithm/ranges_copy.h>
1527#include <__algorithm/ranges_copy_backward.h>
1528#include <__algorithm/ranges_copy_if.h>
1529#include <__algorithm/ranges_copy_n.h>
Nikolas Klauser1306b102022-04-07 11:02:02[diff] [blame]1530#include <__algorithm/ranges_count.h>
1531#include <__algorithm/ranges_count_if.h>
Nikolas Klauser569d6632022-05-25 09:09:43[diff] [blame]1532#include <__algorithm/ranges_equal.h>
Nikolas Klauser7af89a32022-05-21 16:26:29[diff] [blame]1533#include <__algorithm/ranges_fill.h>
1534#include <__algorithm/ranges_fill_n.h>
Nikolas Klauseree0f8c42022-03-12 00:45:35[diff] [blame]1535#include <__algorithm/ranges_find.h>
Nikolas Klauser101d1e92022-07-13 16:07:26[diff] [blame]1536#include <__algorithm/ranges_find_end.h>
Nikolas Klauserb79b2b62022-06-06 11:57:34[diff] [blame]1537#include <__algorithm/ranges_find_first_of.h>
Nikolas Klauseree0f8c42022-03-12 00:45:35[diff] [blame]1538#include <__algorithm/ranges_find_if.h>
1539#include <__algorithm/ranges_find_if_not.h>
Nikolas Klauser80045e92022-05-04 18:27:07[diff] [blame]1540#include <__algorithm/ranges_for_each.h>
1541#include <__algorithm/ranges_for_each_n.h>
Nikolas Klauser37ba1b92022-05-04 12:19:09[diff] [blame]1542#include <__algorithm/ranges_is_partitioned.h>
Nikolas Klauser11e3ad22022-05-26 14:08:55[diff] [blame]1543#include <__algorithm/ranges_is_sorted.h>
1544#include <__algorithm/ranges_is_sorted_until.h>
Nikolas Klauserafd5a4f2022-06-15 14:24:43[diff] [blame]1545#include <__algorithm/ranges_lexicographical_compare.h>
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]1546#include <__algorithm/ranges_lower_bound.h>
Konstantin Varlamovc945bd02022-07-08 20:46:27[diff] [blame]1547#include <__algorithm/ranges_make_heap.h>
Nikolas Klausere476df52022-04-03 07:17:01[diff] [blame]1548#include <__algorithm/ranges_max.h>
Nikolas Klauser205557c2022-03-07 16:01:52[diff] [blame]1549#include <__algorithm/ranges_max_element.h>
Hui Xie25607d12022-06-26 15:13:43[diff] [blame]1550#include <__algorithm/ranges_merge.h>
Nikolas Klauserf83d8332022-03-18 01:57:08[diff] [blame]1551#include <__algorithm/ranges_min.h>
Nikolas Klauser3b470d12022-02-11 12:11:57[diff] [blame]1552#include <__algorithm/ranges_min_element.h>
Nikolas Klauser58d9ab72022-04-13 20:59:09[diff] [blame]1553#include <__algorithm/ranges_minmax.h>
1554#include <__algorithm/ranges_minmax_element.h>
Nikolas Klauserc2cd15a2022-03-08 22:12:35[diff] [blame]1555#include <__algorithm/ranges_mismatch.h>
Nikolas Klauser2c3bbac2022-06-23 10:23:41[diff] [blame]1556#include <__algorithm/ranges_move.h>
1557#include <__algorithm/ranges_move_backward.h>
Nikolas Klauser0e3dc1a2022-05-26 14:42:46[diff] [blame]1558#include <__algorithm/ranges_none_of.h>
Konstantin Varlamov23c73282022-07-08 03:35:51[diff] [blame]1559#include <__algorithm/ranges_nth_element.h>
varconst5dd19ad2022-07-20 03:10:02[diff] [blame]1560#include <__algorithm/ranges_partial_sort.h>
Konstantin Varlamov8ed702b2022-07-19 04:05:51[diff] [blame]1561#include <__algorithm/ranges_partition.h>
Konstantin Varlamov065202f2022-07-20 08:57:13[diff] [blame^]1562#include <__algorithm/ranges_partition_copy.h>
1563#include <__algorithm/ranges_partition_point.h>
Konstantin Varlamovc945bd02022-07-08 20:46:27[diff] [blame]1564#include <__algorithm/ranges_pop_heap.h>
1565#include <__algorithm/ranges_push_heap.h>
Nikolas Klauserf8cbe3cdf2022-07-06 12:03:00[diff] [blame]1566#include <__algorithm/ranges_remove.h>
1567#include <__algorithm/ranges_remove_if.h>
Nikolas Klauserff6d5de2022-06-07 07:42:10[diff] [blame]1568#include <__algorithm/ranges_replace.h>
1569#include <__algorithm/ranges_replace_if.h>
Nikolas Klauser1d1a1912022-05-24 08:32:50[diff] [blame]1570#include <__algorithm/ranges_reverse.h>
Nikolas Klauser7d426a32022-07-11 15:07:35[diff] [blame]1571#include <__algorithm/ranges_reverse_copy.h>
1572#include <__algorithm/ranges_rotate_copy.h>
Nikolas Klauser101d1e92022-07-13 16:07:26[diff] [blame]1573#include <__algorithm/ranges_search.h>
1574#include <__algorithm/ranges_search_n.h>
Hui Xie1cdec6c2022-06-26 15:13:43[diff] [blame]1575#include <__algorithm/ranges_set_difference.h>
Hui Xie96b674f2022-07-08 14:21:40[diff] [blame]1576#include <__algorithm/ranges_set_intersection.h>
Hui Xiea5c06382022-07-11 22:39:59[diff] [blame]1577#include <__algorithm/ranges_set_symmetric_difference.h>
Hui Xie3151b952022-07-13 16:20:22[diff] [blame]1578#include <__algorithm/ranges_set_union.h>
Konstantin Varlamovff3989e2022-06-16 22:20:53[diff] [blame]1579#include <__algorithm/ranges_sort.h>
Konstantin Varlamovc945bd02022-07-08 20:46:27[diff] [blame]1580#include <__algorithm/ranges_sort_heap.h>
Konstantin Varlamov8ed702b2022-07-19 04:05:51[diff] [blame]1581#include <__algorithm/ranges_stable_partition.h>
Konstantin Varlamov94c7b892022-07-01 23:34:08[diff] [blame]1582#include <__algorithm/ranges_stable_sort.h>
Nikolas Klauser9d905312022-02-10 12:33:03[diff] [blame]1583#include <__algorithm/ranges_swap_ranges.h>
Nikolas Klauser3ba85482022-04-05 09:05:36[diff] [blame]1584#include <__algorithm/ranges_transform.h>
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]1585#include <__algorithm/ranges_upper_bound.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1586#include <__algorithm/remove.h>
1587#include <__algorithm/remove_copy.h>
1588#include <__algorithm/remove_copy_if.h>
1589#include <__algorithm/remove_if.h>
1590#include <__algorithm/replace.h>
1591#include <__algorithm/replace_copy.h>
1592#include <__algorithm/replace_copy_if.h>
1593#include <__algorithm/replace_if.h>
1594#include <__algorithm/reverse.h>
1595#include <__algorithm/reverse_copy.h>
1596#include <__algorithm/rotate.h>
1597#include <__algorithm/rotate_copy.h>
1598#include <__algorithm/sample.h>
1599#include <__algorithm/search.h>
1600#include <__algorithm/search_n.h>
1601#include <__algorithm/set_difference.h>
1602#include <__algorithm/set_intersection.h>
1603#include <__algorithm/set_symmetric_difference.h>
1604#include <__algorithm/set_union.h>
1605#include <__algorithm/shift_left.h>
1606#include <__algorithm/shift_right.h>
1607#include <__algorithm/shuffle.h>
1608#include <__algorithm/sift_down.h>
1609#include <__algorithm/sort.h>
1610#include <__algorithm/sort_heap.h>
1611#include <__algorithm/stable_partition.h>
1612#include <__algorithm/stable_sort.h>
Christopher Di Bella6adbc832021-06-05 02:47:47[diff] [blame]1613#include <__algorithm/swap_ranges.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1614#include <__algorithm/transform.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1615#include <__algorithm/unique.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]1616#include <__algorithm/unique_copy.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1617#include <__algorithm/unwrap_iter.h>
1618#include <__algorithm/upper_bound.h>
Eric Fiselierc1bd9192014-08-10 23:53:08[diff] [blame]1619
Louis Dionnede4a57c2022-06-27 19:53:41[diff] [blame]1620#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
1621# include <chrono>
1622# include <iterator>
1623# include <utility>
1624#endif
1625
Nikolas Klauserdb1978b2022-06-16 20:43:46[diff] [blame]1626// standard-mandated includes
1627#include <initializer_list>
1628
Howard Hinnant073458b2011-10-17 20:05:10[diff] [blame]1629#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Arthur O'Dwyerfa6b9e42022-02-02 01:16:40[diff] [blame]1630# pragma GCC system_header
Howard Hinnant073458b2011-10-17 20:05:10[diff] [blame]1631#endif
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1632
Louis Dionne0a06eb92019-08-05 18:29:14[diff] [blame]1633#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
Louis Dionne95689242019-08-06 21:11:24[diff] [blame]1634# include <__pstl_algorithm>
Louis Dionne0a06eb92019-08-05 18:29:14[diff] [blame]1635#endif
1636
Louis Dionne4cd6ca12021-04-20 16:03:32[diff] [blame]1637#endif // _LIBCPP_ALGORITHM