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