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 // 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 620