1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
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
7//
8//===----------------------------------------------------------------------===//
9
10export namespace std {
11  namespace ranges {
12    // [algorithms.results], algorithm result types
13    using std::ranges::in_found_result;
14    using std::ranges::in_fun_result;
15    using std::ranges::in_in_out_result;
16    using std::ranges::in_in_result;
17    using std::ranges::in_out_out_result;
18    using std::ranges::in_out_result;
19#if _LIBCPP_STD_VER >= 23
20    using std::ranges::in_value_result;
21#endif
22    using std::ranges::min_max_result;
23    // using std::ranges::out_value_result;
24  } // namespace ranges
25
26  // [alg.nonmodifying], non-modifying sequence operations
27  // [alg.all.of], all of
28  using std::all_of;
29  namespace ranges {
30    using std::ranges::all_of;
31  }
32
33  // [alg.any.of], any of
34  using std::any_of;
35  namespace ranges {
36    using std::ranges::any_of;
37  }
38
39  // [alg.none.of], none of
40  using std::none_of;
41  namespace ranges {
42    using std::ranges::none_of;
43  }
44
45#if _LIBCPP_STD_VER >= 23
46  // [alg.contains], contains
47  namespace ranges {
48    using std::ranges::contains;
49#if 0
50    using std::ranges::contains_subrange;
51#endif
52  } // namespace ranges
53#endif // _LIBCPP_STD_VER >= 23
54
55  // [alg.foreach], for each
56  using std::for_each;
57
58  namespace ranges {
59    using std::ranges::for_each;
60    using std::ranges::for_each_result;
61  } // namespace ranges
62
63  using std::for_each_n;
64
65  namespace ranges {
66    using std::ranges::for_each_n_result;
67
68    using std::ranges::for_each_n;
69  } // namespace ranges
70
71  // [alg.find], find
72  using std::find;
73  using std::find_if;
74  using std::find_if_not;
75
76  namespace ranges {
77    using std::ranges::find;
78    using std::ranges::find_if;
79    using std::ranges::find_if_not;
80  } // namespace ranges
81
82  namespace ranges {
83#if 0
84    using std::ranges::find_last;
85    using std::ranges::find_last_if;
86    using std::ranges::find_last_if_not;
87#endif
88  } // namespace ranges
89
90  // [alg.find.end], find end
91  using std::find_end;
92
93  namespace ranges {
94    using std::ranges::find_end;
95  }
96
97  // [alg.find.first.of], find first
98  using std::find_first_of;
99
100  namespace ranges {
101    using std::ranges::find_first_of;
102  }
103
104  // [alg.adjacent.find], adjacent find
105  using std::adjacent_find;
106
107  namespace ranges {
108    using std::ranges::adjacent_find;
109  }
110
111  // [alg.count], count
112  using std::count;
113  using std::count_if;
114
115  namespace ranges {
116    using std::ranges::count;
117    using std::ranges::count_if;
118  } // namespace ranges
119
120  // [mismatch], mismatch
121  using std::mismatch;
122
123  namespace ranges {
124    using std::ranges::mismatch_result;
125
126    using std::ranges::mismatch;
127  } // namespace ranges
128
129  // [alg.equal], equal
130  using std::equal;
131
132  namespace ranges {
133    using std::ranges::equal;
134  }
135
136  // [alg.is.permutation], is permutation
137  using std::is_permutation;
138
139  namespace ranges {
140    using std::ranges::is_permutation;
141  }
142
143  // [alg.search], search
144  using std::search;
145
146  namespace ranges {
147    using std::ranges::search;
148  }
149
150  using std::search_n;
151
152  namespace ranges {
153    using std::ranges::search_n;
154  }
155
156  namespace ranges {
157#if _LIBCPP_STD_VER >= 23
158    // [alg.starts.with], starts with
159    using std::ranges::starts_with;
160
161    // [alg.ends.with], ends with
162    using std::ranges::ends_with;
163
164    // [alg.fold], fold
165    using std::ranges::fold_left;
166    using std::ranges::fold_left_with_iter;
167    using std::ranges::fold_left_with_iter_result;
168#  if 0
169    using std::ranges::fold_left_first;
170    using std::ranges::fold_right;
171    using std::ranges::fold_right_last;
172    using std::ranges::fold_left_with_iter;
173    using std::ranges::fold_left_first_with_iter;
174    using std::ranges::fold_left_first_with_iter;
175#  endif
176#endif // _LIBCPP_STD_VER >= 23
177  }    // namespace ranges
178
179  // [alg.modifying.operations], mutating sequence operations
180  // [alg.copy], copy
181  using std::copy;
182
183  namespace ranges {
184    using std::ranges::copy;
185    using std::ranges::copy_result;
186  } // namespace ranges
187
188  using std::copy_n;
189
190  namespace ranges {
191    using std::ranges::copy_n;
192    using std::ranges::copy_n_result;
193  } // namespace ranges
194
195  using std::copy_if;
196
197  namespace ranges {
198    using std::ranges::copy_if;
199    using std::ranges::copy_if_result;
200  } // namespace ranges
201
202  using std::copy_backward;
203
204  namespace ranges {
205    using std::ranges::copy_backward;
206    using std::ranges::copy_backward_result;
207  } // namespace ranges
208
209  // [alg.move], move
210  using std::move;
211
212  namespace ranges {
213    using std::ranges::move;
214    using std::ranges::move_result;
215  } // namespace ranges
216
217  using std::move_backward;
218
219  namespace ranges {
220    using std::ranges::move_backward;
221    using std::ranges::move_backward_result;
222  } // namespace ranges
223
224  // [alg.swap], swap
225  using std::swap_ranges;
226
227  namespace ranges {
228    using std::ranges::swap_ranges;
229    using std::ranges::swap_ranges_result;
230  } // namespace ranges
231
232  using std::iter_swap;
233
234  // [alg.transform], transform
235  using std::transform;
236
237  namespace ranges {
238    using std::ranges::binary_transform_result;
239    using std::ranges::unary_transform_result;
240
241    using std::ranges::transform;
242
243  } // namespace ranges
244
245  using std::replace;
246  using std::replace_if;
247
248  namespace ranges {
249    using std::ranges::replace;
250    using std::ranges::replace_if;
251  } // namespace ranges
252
253  using std::replace_copy;
254  using std::replace_copy_if;
255
256  namespace ranges {
257    using std::ranges::replace_copy;
258    using std::ranges::replace_copy_if;
259    using std::ranges::replace_copy_if_result;
260    using std::ranges::replace_copy_result;
261  } // namespace ranges
262
263  // [alg.fill], fill
264  using std::fill;
265  using std::fill_n;
266
267  namespace ranges {
268    using std::ranges::fill;
269    using std::ranges::fill_n;
270  } // namespace ranges
271
272  // [alg.generate], generate
273  using std::generate;
274  using std::generate_n;
275
276  namespace ranges {
277    using std::ranges::generate;
278    using std::ranges::generate_n;
279  } // namespace ranges
280
281  // [alg.remove], remove
282  using std::remove;
283  using std::remove_if;
284
285  namespace ranges {
286    using std::ranges::remove;
287    using std::ranges::remove_if;
288  } // namespace ranges
289
290  using std::remove_copy;
291  using std::remove_copy_if;
292  namespace ranges {
293    using std::ranges::remove_copy;
294    using std::ranges::remove_copy_if;
295    using std::ranges::remove_copy_if_result;
296    using std::ranges::remove_copy_result;
297  } // namespace ranges
298
299  // [alg.unique], unique
300  using std::unique;
301
302  namespace ranges {
303    using std::ranges::unique;
304  }
305
306  using std::unique_copy;
307
308  namespace ranges {
309    using std::ranges::unique_copy;
310    using std::ranges::unique_copy_result;
311  } // namespace ranges
312
313  // [alg.reverse], reverse
314  using std::reverse;
315
316  namespace ranges {
317    using std::ranges::reverse;
318  }
319
320  using std::reverse_copy;
321
322  namespace ranges {
323    using std::ranges::reverse_copy;
324    using std::ranges::reverse_copy_result;
325  } // namespace ranges
326
327  // [alg.rotate], rotate
328  using std::rotate;
329
330  namespace ranges {
331    using std::ranges::rotate;
332  }
333
334  using std::rotate_copy;
335
336  namespace ranges {
337    using std::ranges::rotate_copy;
338    using std::ranges::rotate_copy_result;
339  } // namespace ranges
340
341  // [alg.random.sample], sample
342  using std::sample;
343
344  namespace ranges {
345    using std::ranges::sample;
346  }
347
348  // [alg.random.shuffle], shuffle
349  using std::shuffle;
350
351  namespace ranges {
352    using std::ranges::shuffle;
353  }
354
355  // [alg.shift], shift
356  using std::shift_left;
357
358  namespace ranges {
359    // using std::ranges::shift_left;
360  }
361
362  using std::shift_right;
363
364  namespace ranges {
365    // using std::ranges::shift_right;
366  }
367
368  // [alg.sorting], sorting and related operations
369  // [alg.sort], sorting
370  using std::sort;
371
372  namespace ranges {
373    using std::ranges::sort;
374  }
375
376  using std::stable_sort;
377
378  namespace ranges {
379    using std::ranges::stable_sort;
380  }
381
382  using std::partial_sort;
383
384  namespace ranges {
385    using std::ranges::partial_sort;
386  }
387  using std::partial_sort_copy;
388
389  namespace ranges {
390    using std::ranges::partial_sort_copy;
391    using std::ranges::partial_sort_copy_result;
392  } // namespace ranges
393
394  using std::is_sorted;
395  using std::is_sorted_until;
396
397  namespace ranges {
398    using std::ranges::is_sorted;
399    using std::ranges::is_sorted_until;
400  } // namespace ranges
401
402  // [alg.nth.element], Nth element
403  using std::nth_element;
404
405  namespace ranges {
406    using std::ranges::nth_element;
407  }
408
409  // [alg.binary.search], binary search
410  using std::lower_bound;
411
412  namespace ranges {
413    using std::ranges::lower_bound;
414  }
415
416  using std::upper_bound;
417
418  namespace ranges {
419    using std::ranges::upper_bound;
420  }
421
422  using std::equal_range;
423
424  namespace ranges {
425    using std::ranges::equal_range;
426  }
427
428  using std::binary_search;
429
430  namespace ranges {
431    using std::ranges::binary_search;
432  }
433
434  // [alg.partitions], partitions
435  using std::is_partitioned;
436
437  namespace ranges {
438    using std::ranges::is_partitioned;
439  }
440
441  using std::partition;
442
443  namespace ranges {
444    using std::ranges::partition;
445  }
446
447  using std::stable_partition;
448
449  namespace ranges {
450    using std::ranges::stable_partition;
451  }
452
453  using std::partition_copy;
454
455  namespace ranges {
456    using std::ranges::partition_copy;
457    using std::ranges::partition_copy_result;
458  } // namespace ranges
459
460  using std::partition_point;
461
462  namespace ranges {
463    using std::ranges::partition_point;
464  }
465  // [alg.merge], merge
466  using std::merge;
467  namespace ranges {
468    using std::ranges::merge;
469    using std::ranges::merge_result;
470  } // namespace ranges
471
472  using std::inplace_merge;
473
474  namespace ranges {
475    using std::ranges::inplace_merge;
476  }
477
478  // [alg.set.operations], set operations
479  using std::includes;
480  namespace ranges {
481    using std::ranges::includes;
482  }
483
484  using std::set_union;
485
486  namespace ranges {
487    using std::ranges::set_union;
488    using std::ranges::set_union_result;
489  } // namespace ranges
490
491  using std::set_intersection;
492  namespace ranges {
493    using std::ranges::set_intersection;
494    using std::ranges::set_intersection_result;
495  } // namespace ranges
496
497  using std::set_difference;
498
499  namespace ranges {
500    using std::ranges::set_difference;
501    using std::ranges::set_difference_result;
502  } // namespace ranges
503
504  using std::set_symmetric_difference;
505
506  namespace ranges {
507    using std::ranges::set_symmetric_difference_result;
508
509    using std::ranges::set_symmetric_difference;
510  } // namespace ranges
511
512  // [alg.heap.operations], heap operations
513  using std::push_heap;
514
515  namespace ranges {
516    using std::ranges::push_heap;
517  }
518
519  using std::pop_heap;
520
521  namespace ranges {
522    using std::ranges::pop_heap;
523  }
524
525  using std::make_heap;
526
527  namespace ranges {
528    using std::ranges::make_heap;
529  }
530
531  using std::sort_heap;
532
533  namespace ranges {
534    using std::ranges::sort_heap;
535  }
536
537  using std::is_heap;
538
539  namespace ranges {
540    using std::ranges::is_heap;
541  }
542
543  using std::is_heap_until;
544
545  namespace ranges {
546    using std::ranges::is_heap_until;
547  }
548
549  // [alg.min.max], minimum and maximum
550  using std::min;
551
552  namespace ranges {
553    using std::ranges::min;
554  }
555
556  using std::max;
557
558  namespace ranges {
559    using std::ranges::max;
560  }
561
562  using std::minmax;
563
564  namespace ranges {
565    using std::ranges::minmax_result;
566
567    using std::ranges::minmax;
568  } // namespace ranges
569
570  using std::min_element;
571
572  namespace ranges {
573    using std::ranges::min_element;
574  }
575
576  using std::max_element;
577
578  namespace ranges {
579    using std::ranges::max_element;
580  }
581
582  using std::minmax_element;
583
584  namespace ranges {
585    using std::ranges::minmax_element_result;
586
587    using std::ranges::minmax_element;
588  } // namespace ranges
589    // [alg.clamp], bounded value
590  using std::clamp;
591
592  namespace ranges {
593    using std::ranges::clamp;
594  }
595
596  // [alg.lex.comparison], lexicographical comparison
597  using std::lexicographical_compare;
598
599  namespace ranges {
600    using std::ranges::lexicographical_compare;
601  }
602
603  // [alg.three.way], three-way comparison algorithms
604  using std::lexicographical_compare_three_way;
605
606  // [alg.permutation.generators], permutations
607  using std::next_permutation;
608
609  namespace ranges {
610    using std::ranges::next_permutation_result;
611
612    using std::ranges::next_permutation;
613  } // namespace ranges
614
615  using std::prev_permutation;
616
617  namespace ranges {
618    using std::ranges::prev_permutation_result;
619
620    using std::ranges::prev_permutation;
621  } // namespace ranges
622
623} // namespace std
624