libcxx/modules/std/algorithm.inc

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