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 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 namespace ranges { 81#if 0 82 using std::ranges::find_last; 83 using std::ranges::find_last_if; 84 using std::ranges::find_last_if_not; 85#endif 86 } // namespace ranges 87 88 // [alg.find.end], find end 89 using std::find_end; 90 91 namespace ranges { 92 using std::ranges::find_end; 93 } 94 95 // [alg.find.first.of], find first 96 using std::find_first_of; 97 98 namespace ranges { 99 using std::ranges::find_first_of; 100 } 101 102 // [alg.adjacent.find], adjacent find 103 using std::adjacent_find; 104 105 namespace ranges { 106 using std::ranges::adjacent_find; 107 } 108 109 // [alg.count], count 110 using std::count; 111 using std::count_if; 112 113 namespace ranges { 114 using std::ranges::count; 115 using std::ranges::count_if; 116 } // namespace ranges 117 118 // [mismatch], mismatch 119 using std::mismatch; 120 121 namespace ranges { 122 using std::ranges::mismatch_result; 123 124 using std::ranges::mismatch; 125 } // namespace ranges 126 127 // [alg.equal], equal 128 using std::equal; 129 130 namespace ranges { 131 using std::ranges::equal; 132 } 133 134 // [alg.is.permutation], is permutation 135 using std::is_permutation; 136 137 namespace ranges { 138 using std::ranges::is_permutation; 139 } 140 141 // [alg.search], search 142 using std::search; 143 144 namespace ranges { 145 using std::ranges::search; 146 } 147 148 using std::search_n; 149 150 namespace ranges { 151 using std::ranges::search_n; 152 } 153 154 namespace ranges { 155#if _LIBCPP_STD_VER >= 23 156 // [alg.starts.with], starts with 157 using std::ranges::starts_with; 158 159 // [alg.ends.with], ends with 160 using std::ranges::ends_with; 161 162 // [alg.fold], fold 163 using std::ranges::fold_left; 164 using std::ranges::fold_left_with_iter; 165 using std::ranges::fold_left_with_iter_result; 166# if 0 167 using std::ranges::fold_left_first; 168 using std::ranges::fold_right; 169 using std::ranges::fold_right_last; 170 using std::ranges::fold_left_with_iter; 171 using std::ranges::fold_left_first_with_iter; 172 using std::ranges::fold_left_first_with_iter; 173# endif 174#endif // _LIBCPP_STD_VER >= 23 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