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