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