[libc++] Replace _VSTD with std in __ranges/

[• Quuxplusone]

Assuming this is a completely mechanical sed -i -e s/_VSTD::/std::/g ../libcxx/include/__ranges/*.h, and assuming that you'll actually redo the sed immediately before pushing it (to avoid any merge/rebase conflicts), this seems technically fine to me.
My impression is that we absolutely don't want to do this kind of replacement on e.g. __algorithm/, __memory/, etc, because that would annoy downstream vendors; but perhaps __ranges/ is so new that it's a special case? Therefore I defer to @ldionne on this more-political-than-technical question.

[Mordante]

LGTM from my side especially since there were no objections on Discord for the change to ranges.
However since I've no patches for ranges that can be conflicting I leave approval to those who work actively in the ranges code.

[ldionne]

LGTM, but please make sure you re-run the sed before committing, in case there were race conditions.

Also, I looked at the patch and that seems to be the case, but I am assuming that this is purely a change from _VSTD:: to std:: (and so technically we could make this patch a no-op by reverting to _VSTD::). If that's not the case, please call it out.

libcxx/include/__ranges/all.h

 namespace ranges::views {
 
 namespace __all {
   struct __fn : __range_adaptor_closure<__fn> {
     template<class _Tp>
       requires ranges::view<decay_t<_Tp>>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(_VSTD::forward<_Tp>(__t))))
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Tp>(__t))))
     {
-      return _LIBCPP_AUTO_CAST(_VSTD::forward<_Tp>(__t));
+      return _LIBCPP_AUTO_CAST(std::forward<_Tp>(__t));
     }
 
     template<class _Tp>
       requires (!ranges::view<decay_t<_Tp>>) &&
-               requires (_Tp&& __t) { ranges::ref_view{_VSTD::forward<_Tp>(__t)}; }
+               requires (_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; }
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::ref_view{_VSTD::forward<_Tp>(__t)}))
+      noexcept(noexcept(ranges::ref_view{std::forward<_Tp>(__t)}))
     {
-      return ranges::ref_view{_VSTD::forward<_Tp>(__t)};
+      return ranges::ref_view{std::forward<_Tp>(__t)};
     }
 
     template<class _Tp>
       requires (!ranges::view<decay_t<_Tp>> &&
-                !requires (_Tp&& __t) { ranges::ref_view{_VSTD::forward<_Tp>(__t)}; } &&
-                 requires (_Tp&& __t) { ranges::owning_view{_VSTD::forward<_Tp>(__t)}; })
+                !requires (_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; } &&
+                 requires (_Tp&& __t) { ranges::owning_view{std::forward<_Tp>(__t)}; })
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::owning_view{_VSTD::forward<_Tp>(__t)}))
+      noexcept(noexcept(ranges::owning_view{std::forward<_Tp>(__t)}))
     {
-      return ranges::owning_view{_VSTD::forward<_Tp>(__t)};
+      return ranges::owning_view{std::forward<_Tp>(__t)};
     }
   };
 } // namespace __all
 
 inline namespace __cpo {
   inline constexpr auto all = __all::__fn{};
 } // namespace __cpo
 

libcxx/include/__ranges/common_view.h

 class common_view : public view_interface<common_view<_View>> {
   _View __base_ = _View();
 
 public:
   _LIBCPP_HIDE_FROM_ABI
   common_view() requires default_initializable<_View> = default;
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit common_view(_View __v) : __base_(_VSTD::move(__v)) { }
+  constexpr explicit common_view(_View __v) : __base_(std::move(__v)) { }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return _VSTD::move(__base_); }
+  constexpr _View base() && { return std::move(__base_); }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto begin() {
     if constexpr (random_access_range<_View> && sized_range<_View>)
       return ranges::begin(__base_);
     else
       return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::begin(__base_));
   }

 
 namespace views {
 namespace __common {
   struct __fn : __range_adaptor_closure<__fn> {
     template<class _Range>
       requires common_range<_Range>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Range&& __range) const
-      noexcept(noexcept(views::all(_VSTD::forward<_Range>(__range))))
-      -> decltype(      views::all(_VSTD::forward<_Range>(__range)))
-      { return          views::all(_VSTD::forward<_Range>(__range)); }
+      noexcept(noexcept(views::all(std::forward<_Range>(__range))))
+      -> decltype(      views::all(std::forward<_Range>(__range)))
+      { return          views::all(std::forward<_Range>(__range)); }
 
     template<class _Range>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Range&& __range) const
-      noexcept(noexcept(common_view{_VSTD::forward<_Range>(__range)}))
-      -> decltype(      common_view{_VSTD::forward<_Range>(__range)})
-      { return          common_view{_VSTD::forward<_Range>(__range)}; }
+      noexcept(noexcept(common_view{std::forward<_Range>(__range)}))
+      -> decltype(      common_view{std::forward<_Range>(__range)})
+      { return          common_view{std::forward<_Range>(__range)}; }
   };
 } // namespace __common
 
 inline namespace __cpo {
   inline constexpr auto common = __common::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_COMMON_VIEW_H

libcxx/include/__ranges/copyable_box.h

class __copyable_box {
     _LIBCPP_NO_UNIQUE_ADDRESS optional<_Tp> __val_;
 
   public:
     template<class ..._Args>
       requires is_constructible_v<_Tp, _Args...>
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
       noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
-      : __val_(in_place, _VSTD::forward<_Args>(__args)...)
+      : __val_(in_place, std::forward<_Args>(__args)...)
     { }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
       requires default_initializable<_Tp>
       : __val_(in_place)
     { }
 
     _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
     _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __copyable_box& operator=(__copyable_box const& __other)
       noexcept(is_nothrow_copy_constructible_v<_Tp>)
     {
-      if (this != _VSTD::addressof(__other)) {
+      if (this != std::addressof(__other)) {
         if (__other.__has_value()) __val_.emplace(*__other);
         else                       __val_.reset();
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __copyable_box& operator=(__copyable_box&& __other)
       noexcept(is_nothrow_move_constructible_v<_Tp>)
     {
-      if (this != _VSTD::addressof(__other)) {
-        if (__other.__has_value()) __val_.emplace(_VSTD::move(*__other));
+      if (this != std::addressof(__other)) {
+        if (__other.__has_value()) __val_.emplace(std::move(*__other));
         else                       __val_.reset();
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return *__val_; }
     _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return *__val_; }
 
class __copyable_box<_Tp> {
     _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
 
   public:
     template<class ..._Args>
       requires is_constructible_v<_Tp, _Args...>
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
       noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
-      : __val_(_VSTD::forward<_Args>(__args)...)
+      : __val_(std::forward<_Args>(__args)...)
     { }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
       requires default_initializable<_Tp>
       : __val_()
     { }
 
     _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
     _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
 
     // Implementation of assignment operators in case we perform optimization (1)
     _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box const&) requires copyable<_Tp> = default;
     _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
 
     // Implementation of assignment operators in case we perform optimization (2)
     _LIBCPP_HIDE_FROM_ABI
     constexpr __copyable_box& operator=(__copyable_box const& __other) noexcept {
       static_assert(is_nothrow_copy_constructible_v<_Tp>);
-      if (this != _VSTD::addressof(__other)) {
-        _VSTD::destroy_at(_VSTD::addressof(__val_));
-        _VSTD::construct_at(_VSTD::addressof(__val_), __other.__val_);
+      if (this != std::addressof(__other)) {
+        std::destroy_at(std::addressof(__val_));
+        std::construct_at(std::addressof(__val_), __other.__val_);
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __copyable_box& operator=(__copyable_box&& __other) noexcept {
       static_assert(is_nothrow_move_constructible_v<_Tp>);
-      if (this != _VSTD::addressof(__other)) {
-        _VSTD::destroy_at(_VSTD::addressof(__val_));
-        _VSTD::construct_at(_VSTD::addressof(__val_), _VSTD::move(__other.__val_));
+      if (this != std::addressof(__other)) {
+        std::destroy_at(std::addressof(__val_));
+        std::construct_at(std::addressof(__val_), std::move(__other.__val_));
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return __val_; }
     _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return __val_; }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return _VSTD::addressof(__val_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return _VSTD::addressof(__val_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return std::addressof(__val_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return std::addressof(__val_); }
 
     _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; }
   };
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_COPYABLE_BOX_H

libcxx/include/__ranges/counted.h

 namespace ranges::views {
 
 namespace __counted {
 
   struct __fn {
     template<contiguous_iterator _It>
     _LIBCPP_HIDE_FROM_ABI
     static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
-      noexcept(noexcept(span(_VSTD::to_address(__it), static_cast<size_t>(__count))))
+      noexcept(noexcept(span(std::to_address(__it), static_cast<size_t>(__count))))
       // Deliberately omit return-type SFINAE, because to_address is not SFINAE-friendly
-      { return          span(_VSTD::to_address(__it), static_cast<size_t>(__count)); }
+      { return          span(std::to_address(__it), static_cast<size_t>(__count)); }
 
     template<random_access_iterator _It>
     _LIBCPP_HIDE_FROM_ABI
     static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
       noexcept(noexcept(subrange(__it, __it + __count)))
       -> decltype(      subrange(__it, __it + __count))
       { return          subrange(__it, __it + __count); }
 
     template<class _It>
     _LIBCPP_HIDE_FROM_ABI
     static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
-      noexcept(noexcept(subrange(counted_iterator(_VSTD::move(__it), __count), default_sentinel)))
-      -> decltype(      subrange(counted_iterator(_VSTD::move(__it), __count), default_sentinel))
-      { return          subrange(counted_iterator(_VSTD::move(__it), __count), default_sentinel); }
+      noexcept(noexcept(subrange(counted_iterator(std::move(__it), __count), default_sentinel)))
+      -> decltype(      subrange(counted_iterator(std::move(__it), __count), default_sentinel))
+      { return          subrange(counted_iterator(std::move(__it), __count), default_sentinel); }
 
     template<class _It, convertible_to<iter_difference_t<_It>> _Diff>
       requires input_or_output_iterator<decay_t<_It>>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_It&& __it, _Diff&& __count) const
-      noexcept(noexcept(__go(_VSTD::forward<_It>(__it), _VSTD::forward<_Diff>(__count))))
-      -> decltype(      __go(_VSTD::forward<_It>(__it), _VSTD::forward<_Diff>(__count)))
-      { return          __go(_VSTD::forward<_It>(__it), _VSTD::forward<_Diff>(__count)); }
+      noexcept(noexcept(__go(std::forward<_It>(__it), std::forward<_Diff>(__count))))
+      -> decltype(      __go(std::forward<_It>(__it), std::forward<_Diff>(__count)))
+      { return          __go(std::forward<_It>(__it), std::forward<_Diff>(__count)); }
   };
 
 } // namespace __counted
 
 inline namespace __cpo {
   inline constexpr auto counted = __counted::__fn{};
 } // namespace __cpo
 
 } // namespace ranges::views
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_COUNTED_H

libcxx/include/__ranges/data.h

struct __fn {
     constexpr auto operator()(_Tp&& __t) const
         noexcept(noexcept(__t.data())) {
       return __t.data();
     }
 
     template<__ranges_begin_invocable _Tp>
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Tp&& __t) const
-        noexcept(noexcept(_VSTD::to_address(ranges::begin(__t)))) {
-      return _VSTD::to_address(ranges::begin(__t));
+        noexcept(noexcept(std::to_address(ranges::begin(__t)))) {
+      return std::to_address(ranges::begin(__t));
     }
   };
 } // namespace __data
 
 inline namespace __cpo {
   inline constexpr auto data = __data::__fn{};
 } // namespace __cpo
 } // namespace ranges

libcxx/include/__ranges/drop_view.h

class drop_view
     _View __base_ = _View();
 
 public:
     drop_view() requires default_initializable<_View> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr drop_view(_View __base, range_difference_t<_View> __count)
       : __count_(__count)
-      , __base_(_VSTD::move(__base))
+      , __base_(std::move(__base))
     {
       _LIBCPP_ASSERT(__count_ >= 0, "count must be greater than or equal to zero.");
     }
 
     _LIBCPP_HIDE_FROM_ABI constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return _VSTD::move(__base_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto begin()
       requires (!(__simple_view<_View> &&
                   random_access_range<const _View> && sized_range<const _View>))
     {
       if constexpr (_UseCache)
         if (__cached_begin_.__has_value())

libcxx/include/__ranges/iota_view.h

struct __iterator : public __iota_iterator_category<_Start> {
       using difference_type = _IotaDiffT<_Start>;
 
       _Start __value_ = _Start();
 
       _LIBCPP_HIDE_FROM_ABI
       __iterator() requires default_initializable<_Start> = default;
 
       _LIBCPP_HIDE_FROM_ABI
-      constexpr explicit __iterator(_Start __value) : __value_(_VSTD::move(__value)) {}
+      constexpr explicit __iterator(_Start __value) : __value_(std::move(__value)) {}
 
       _LIBCPP_HIDE_FROM_ABI
       constexpr _Start operator*() const noexcept(is_nothrow_copy_constructible_v<_Start>) {
         return __value_;
       }
 
       _LIBCPP_HIDE_FROM_ABI
       constexpr __iterator& operator++() {
struct __sentinel {
       friend class iota_view;
 
     private:
       _Bound __bound_ = _Bound();
 
     public:
       _LIBCPP_HIDE_FROM_ABI
       __sentinel() = default;
-      constexpr explicit __sentinel(_Bound __bound) : __bound_(_VSTD::move(__bound)) {}
+      constexpr explicit __sentinel(_Bound __bound) : __bound_(std::move(__bound)) {}
 
       _LIBCPP_HIDE_FROM_ABI
       friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
         return __x.__value_ == __y.__bound_;
       }
 
       _LIBCPP_HIDE_FROM_ABI
       friend constexpr iter_difference_t<_Start> operator-(const __iterator& __x, const __sentinel& __y)
class iota_view : public view_interface<iota_view<_Start, _Bound>> {
     _Start __value_ = _Start();
     _Bound __bound_ = _Bound();
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     iota_view() requires default_initializable<_Start> = default;
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit iota_view(_Start __value) : __value_(_VSTD::move(__value)) { }
+    constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) { }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr iota_view(type_identity_t<_Start> __value, type_identity_t<_Bound> __bound)
-      : __value_(_VSTD::move(__value)), __bound_(_VSTD::move(__bound)) {
+      : __value_(std::move(__value)), __bound_(std::move(__bound)) {
       // Validate the precondition if possible.
       if constexpr (totally_ordered_with<_Start, _Bound>) {
         _LIBCPP_ASSERT(ranges::less_equal()(__value_, __bound_),
                        "Precondition violated: value is greater than bound.");
       }
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr iota_view(__iterator __first, __iterator __last)
       requires same_as<_Start, _Bound>
-      : iota_view(_VSTD::move(__first.__value_), _VSTD::move(__last.__value_)) {}
+      : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr iota_view(__iterator __first, _Bound __last)
       requires same_as<_Bound, unreachable_sentinel_t>
-      : iota_view(_VSTD::move(__first.__value_), _VSTD::move(__last)) {}
+      : iota_view(std::move(__first.__value_), std::move(__last)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr iota_view(__iterator __first, __sentinel __last)
       requires (!same_as<_Start, _Bound> && !same_as<_Start, unreachable_sentinel_t>)
-      : iota_view(_VSTD::move(__first.__value_), _VSTD::move(__last.__bound_)) {}
+      : iota_view(std::move(__first.__value_), std::move(__last.__bound_)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __iterator begin() const { return __iterator{__value_}; }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto end() const {
       if constexpr (same_as<_Bound, unreachable_sentinel_t>)
         return unreachable_sentinel;
public:
     constexpr auto size() const
       requires (same_as<_Start, _Bound> && __advanceable<_Start>) ||
                (integral<_Start> && integral<_Bound>) ||
                sized_sentinel_for<_Bound, _Start>
     {
       if constexpr (__integer_like<_Start> && __integer_like<_Bound>) {
         if (__value_ < 0) {
           if (__bound_ < 0) {
-            return _VSTD::__to_unsigned_like(-__value_) - _VSTD::__to_unsigned_like(-__bound_);
+            return std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_);
           }
-          return _VSTD::__to_unsigned_like(__bound_) + _VSTD::__to_unsigned_like(-__value_);
+          return std::__to_unsigned_like(__bound_) + std::__to_unsigned_like(-__value_);
         }
-        return _VSTD::__to_unsigned_like(__bound_) - _VSTD::__to_unsigned_like(__value_);
+        return std::__to_unsigned_like(__bound_) - std::__to_unsigned_like(__value_);
       }
-      return _VSTD::__to_unsigned_like(__bound_ - __value_);
+      return std::__to_unsigned_like(__bound_ - __value_);
     }
   };
 
   template<class _Start, class _Bound>
     requires (!__integer_like<_Start> || !__integer_like<_Bound> ||
               (__signed_integer_like<_Start> == __signed_integer_like<_Bound>))
   iota_view(_Start, _Bound) -> iota_view<_Start, _Bound>;
 
   template<class _Start, class _Bound>
   inline constexpr bool enable_borrowed_range<iota_view<_Start, _Bound>> = true;
 
 namespace views {
 namespace __iota {
   struct __fn {
     template<class _Start>
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Start&& __start) const
-      noexcept(noexcept(ranges::iota_view(_VSTD::forward<_Start>(__start))))
-      -> decltype(      ranges::iota_view(_VSTD::forward<_Start>(__start)))
-      { return          ranges::iota_view(_VSTD::forward<_Start>(__start)); }
+      noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start))))
+      -> decltype(      ranges::iota_view(std::forward<_Start>(__start)))
+      { return          ranges::iota_view(std::forward<_Start>(__start)); }
 
     template<class _Start, class _Bound>
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Start&& __start, _Bound&& __bound) const
-      noexcept(noexcept(ranges::iota_view(_VSTD::forward<_Start>(__start), _VSTD::forward<_Bound>(__bound))))
-      -> decltype(      ranges::iota_view(_VSTD::forward<_Start>(__start), _VSTD::forward<_Bound>(__bound)))
-      { return          ranges::iota_view(_VSTD::forward<_Start>(__start), _VSTD::forward<_Bound>(__bound)); }
+      noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_Bound>(__bound))))
+      -> decltype(      ranges::iota_view(std::forward<_Start>(__start), std::forward<_Bound>(__bound)))
+      { return          ranges::iota_view(std::forward<_Start>(__start), std::forward<_Bound>(__bound)); }
   };
 } // namespace __iota
 
 inline namespace __cpo {
   inline constexpr auto iota = __iota::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_IOTA_VIEW_H

libcxx/include/__ranges/join_view.h

private:
     _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     join_view() requires default_initializable<_View> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit join_view(_View __base)
-      : __base_(_VSTD::move(__base)) {}
+      : __base_(std::move(__base)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return _VSTD::move(__base_); }
+    constexpr _View base() && { return std::move(__base_); }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto begin() {
       constexpr bool __use_const = __simple_view<_View> &&
                                    is_reference_v<range_reference_t<_View>>;
       return __iterator<__use_const>{*this, ranges::begin(__base_)};
     }
 
public:
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit __sentinel(_Parent& __parent)
       : __end_(ranges::end(__parent.__base_)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __sentinel(__sentinel<!_Const> __s)
       requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
-      : __end_(_VSTD::move(__s.__end_)) {}
+      : __end_(std::move(__s.__end_)) {}
 
     template<bool _OtherConst>
       requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
     _LIBCPP_HIDE_FROM_ABI
     friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
       return __x.__outer_ == __y.__end_;
     }
   };
public:
     using difference_type = common_type_t<
       range_difference_t<_Base>, range_difference_t<range_reference_t<_Base>>>;
 
     _LIBCPP_HIDE_FROM_ABI
     __iterator() requires default_initializable<_Outer> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __iterator(_Parent& __parent, _Outer __outer)
-      : __outer_(_VSTD::move(__outer))
-      , __parent_(_VSTD::addressof(__parent)) {
+      : __outer_(std::move(__outer))
+      , __parent_(std::addressof(__parent)) {
       __satisfy();
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __iterator(__iterator<!_Const> __i)
       requires _Const &&
                convertible_to<iterator_t<_View>, _Outer> &&
                convertible_to<iterator_t<_InnerRange>, _Inner>
-      : __outer_(_VSTD::move(__i.__outer_))
-      , __inner_(_VSTD::move(__i.__inner_))
+      : __outer_(std::move(__i.__outer_))
+      , __inner_(std::move(__i.__inner_))
       , __parent_(__i.__parent_) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr decltype(auto) operator*() const {
       return **__inner_;
     }
 
     _LIBCPP_HIDE_FROM_ABI

libcxx/include/__ranges/non_propagating_cache.h

namespace ranges {
   class _LIBCPP_TEMPLATE_VIS __non_propagating_cache {
     struct __from_tag { };
     struct __forward_tag { };
 
     // This helper class is needed to perform copy and move elision when
     // constructing the contained type from an iterator.
     struct __wrapper {
       template<class ..._Args>
-      constexpr explicit __wrapper(__forward_tag, _Args&& ...__args) : __t_(_VSTD::forward<_Args>(__args)...) { }
+      constexpr explicit __wrapper(__forward_tag, _Args&& ...__args) : __t_(std::forward<_Args>(__args)...) { }
       template<class _Fn>
       constexpr explicit __wrapper(__from_tag, _Fn const& __f) : __t_(__f()) { }
       _Tp __t_;
     };
 
     optional<__wrapper> __value_ = nullopt;
 
   public:
     _LIBCPP_HIDE_FROM_ABI __non_propagating_cache() = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __non_propagating_cache(__non_propagating_cache const&) noexcept
       : __value_(nullopt)
     { }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __non_propagating_cache(__non_propagating_cache&& __other) noexcept
       : __value_(nullopt)
     {
       __other.__value_.reset();
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __non_propagating_cache& operator=(__non_propagating_cache const& __other) noexcept {
-      if (this != _VSTD::addressof(__other)) {
+      if (this != std::addressof(__other)) {
         __value_.reset();
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __non_propagating_cache& operator=(__non_propagating_cache&& __other) noexcept {
       __value_.reset();
public:
     _LIBCPP_HIDE_FROM_ABI
     constexpr _Tp& __emplace_from(_Fn const& __f) {
       return __value_.emplace(__from_tag{}, __f).__t_;
     }
 
     template<class ..._Args>
     _LIBCPP_HIDE_FROM_ABI
     constexpr _Tp& __emplace(_Args&& ...__args) {
-      return __value_.emplace(__forward_tag{}, _VSTD::forward<_Args>(__args)...).__t_;
+      return __value_.emplace(__forward_tag{}, std::forward<_Args>(__args)...).__t_;
     }
   };
 
   struct __empty_cache { };
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H

libcxx/include/__ranges/owning_view.h

 namespace ranges {
   template<range _Rp>
     requires movable<_Rp> && (!__is_std_initializer_list<remove_cvref_t<_Rp>>)
   class owning_view : public view_interface<owning_view<_Rp>> {
     _Rp __r_ = _Rp();
 
 public:
     owning_view() requires default_initializable<_Rp> = default;
-    _LIBCPP_HIDE_FROM_ABI constexpr owning_view(_Rp&& __r) : __r_(_VSTD::move(__r)) {}
+    _LIBCPP_HIDE_FROM_ABI constexpr owning_view(_Rp&& __r) : __r_(std::move(__r)) {}
 
     owning_view(owning_view&&) = default;
     owning_view& operator=(owning_view&&) = default;
 
     _LIBCPP_HIDE_FROM_ABI constexpr _Rp& base() & noexcept { return __r_; }
     _LIBCPP_HIDE_FROM_ABI constexpr const _Rp& base() const& noexcept { return __r_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Rp&& base() && noexcept { return _VSTD::move(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Rp&& base() const&& noexcept { return _VSTD::move(__r_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Rp&& base() && noexcept { return std::move(__r_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr const _Rp&& base() const&& noexcept { return std::move(__r_); }
 
     _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Rp> begin() { return ranges::begin(__r_); }
     _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Rp> end() { return ranges::end(__r_); }
     _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const requires range<const _Rp> { return ranges::begin(__r_); }
     _LIBCPP_HIDE_FROM_ABI constexpr auto end() const requires range<const _Rp> { return ranges::end(__r_); }
 
     _LIBCPP_HIDE_FROM_ABI constexpr bool empty() requires requires { ranges::empty(__r_); }
       { return ranges::empty(__r_); }

libcxx/include/__ranges/range_adaptor.h

 // - `f1 | f2` is an adaptor closure `g` such that `g(x)` is equivalent to `f2(f1(x))`
 template <class _Tp>
 struct __range_adaptor_closure;
 
 // Type that wraps an arbitrary function object and makes it into a range adaptor closure,
 // i.e. something that can be called via the `x | f` notation.
 template <class _Fn>
 struct __range_adaptor_closure_t : _Fn, __range_adaptor_closure<__range_adaptor_closure_t<_Fn>> {
-    constexpr explicit __range_adaptor_closure_t(_Fn&& __f) : _Fn(_VSTD::move(__f)) { }
+    constexpr explicit __range_adaptor_closure_t(_Fn&& __f) : _Fn(std::move(__f)) { }
 };
 
 template <class _Tp>
 concept _RangeAdaptorClosure = derived_from<remove_cvref_t<_Tp>, __range_adaptor_closure<remove_cvref_t<_Tp>>>;
 
 template <class _Tp>
 struct __range_adaptor_closure {
     template <ranges::viewable_range _View, _RangeAdaptorClosure _Closure>
         requires same_as<_Tp, remove_cvref_t<_Closure>> &&
                  invocable<_Closure, _View>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     friend constexpr decltype(auto) operator|(_View&& __view, _Closure&& __closure)
         noexcept(is_nothrow_invocable_v<_Closure, _View>)
-    { return _VSTD::invoke(_VSTD::forward<_Closure>(__closure), _VSTD::forward<_View>(__view)); }
+    { return std::invoke(std::forward<_Closure>(__closure), std::forward<_View>(__view)); }
 
     template <_RangeAdaptorClosure _Closure, _RangeAdaptorClosure _OtherClosure>
         requires same_as<_Tp, remove_cvref_t<_Closure>> &&
                  constructible_from<decay_t<_Closure>, _Closure> &&
                  constructible_from<decay_t<_OtherClosure>, _OtherClosure>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     friend constexpr auto operator|(_Closure&& __c1, _OtherClosure&& __c2)
         noexcept(is_nothrow_constructible_v<decay_t<_Closure>, _Closure> &&
                  is_nothrow_constructible_v<decay_t<_OtherClosure>, _OtherClosure>)
-    { return __range_adaptor_closure_t(_VSTD::__compose(_VSTD::forward<_OtherClosure>(__c2), _VSTD::forward<_Closure>(__c1))); }
+    { return __range_adaptor_closure_t(std::__compose(std::forward<_OtherClosure>(__c2), std::forward<_Closure>(__c1))); }
 };
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_RANGE_ADAPTOR_H

libcxx/include/__ranges/ref_view.h

class ref_view : public view_interface<ref_view<_Range>> {
     static void __fun(_Range&&) = delete;
 
 public:
     template<class _Tp>
       requires __different_from<_Tp, ref_view> &&
         convertible_to<_Tp, _Range&> && requires { __fun(declval<_Tp>()); }
     _LIBCPP_HIDE_FROM_ABI
     constexpr ref_view(_Tp&& __t)
-      : __range_(_VSTD::addressof(static_cast<_Range&>(_VSTD::forward<_Tp>(__t))))
+      : __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
     {}
 
     _LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }
 
     _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
     _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
 
     _LIBCPP_HIDE_FROM_ABI

libcxx/include/__ranges/reverse_view.h

class reverse_view : public view_interface<reverse_view<_View>> {
     _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
     _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     reverse_view() requires default_initializable<_View> = default;
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit reverse_view(_View __view) : __base_(_VSTD::move(__view)) {}
+    constexpr explicit reverse_view(_View __view) : __base_(std::move(__view)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return _VSTD::move(__base_); }
+    constexpr _View base() && { return std::move(__base_); }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr reverse_iterator<iterator_t<_View>> begin() {
       if constexpr (_UseCache)
         if (__cached_begin_.__has_value())
           return *__cached_begin_;
 
-      auto __tmp = _VSTD::make_reverse_iterator(ranges::next(ranges::begin(__base_), ranges::end(__base_)));
+      auto __tmp = std::make_reverse_iterator(ranges::next(ranges::begin(__base_), ranges::end(__base_)));
       if constexpr (_UseCache)
         __cached_begin_.__emplace(__tmp);
       return __tmp;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr reverse_iterator<iterator_t<_View>> begin() requires common_range<_View> {
-      return _VSTD::make_reverse_iterator(ranges::end(__base_));
+      return std::make_reverse_iterator(ranges::end(__base_));
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto begin() const requires common_range<const _View> {
-      return _VSTD::make_reverse_iterator(ranges::end(__base_));
+      return std::make_reverse_iterator(ranges::end(__base_));
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr reverse_iterator<iterator_t<_View>> end() {
-      return _VSTD::make_reverse_iterator(ranges::begin(__base_));
+      return std::make_reverse_iterator(ranges::begin(__base_));
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto end() const requires common_range<const _View> {
-      return _VSTD::make_reverse_iterator(ranges::begin(__base_));
+      return std::make_reverse_iterator(ranges::begin(__base_));
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto size() requires sized_range<_View> {
       return ranges::size(__base_);
     }
 
     _LIBCPP_HIDE_FROM_ABI
struct __unwrapped_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> {
       using type = subrange<_Iter, _Iter, _Kind>;
     };
 
     struct __fn : __range_adaptor_closure<__fn> {
       template<class _Range>
         requires __is_reverse_view<remove_cvref_t<_Range>>
       [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
       constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(_VSTD::forward<_Range>(__range).base()))
-        -> decltype(      _VSTD::forward<_Range>(__range).base())
-        { return          _VSTD::forward<_Range>(__range).base(); }
+        noexcept(noexcept(std::forward<_Range>(__range).base()))
+        -> decltype(      std::forward<_Range>(__range).base())
+        { return          std::forward<_Range>(__range).base(); }
 
       template<class _Range,
                class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
         requires __is_sized_reverse_subrange<remove_cvref_t<_Range>>
       [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
       constexpr auto operator()(_Range&& __range) const
         noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size())))
         -> decltype(      _UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size()))
struct __fn : __range_adaptor_closure<__fn> {
         { return          _UnwrappedSubrange(__range.end().base(), __range.begin().base()); }
 
       template<class _Range>
         requires (!__is_reverse_view<remove_cvref_t<_Range>> &&
                   !__is_sized_reverse_subrange<remove_cvref_t<_Range>> &&
                   !__is_unsized_reverse_subrange<remove_cvref_t<_Range>>)
       [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
       constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(reverse_view{_VSTD::forward<_Range>(__range)}))
-        -> decltype(      reverse_view{_VSTD::forward<_Range>(__range)})
-        { return          reverse_view{_VSTD::forward<_Range>(__range)}; }
+        noexcept(noexcept(reverse_view{std::forward<_Range>(__range)}))
+        -> decltype(      reverse_view{std::forward<_Range>(__range)})
+        { return          reverse_view{std::forward<_Range>(__range)}; }
     };
   } // namespace __reverse
 
   inline namespace __cpo {
     inline constexpr auto reverse = __reverse::__fn{};
   } // namespace __cpo
   } // namespace views
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_REVERSE_VIEW_H

libcxx/include/__ranges/single_view.h

namespace ranges {
   public:
     _LIBCPP_HIDE_FROM_ABI
     single_view() requires default_initializable<_Tp> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit single_view(const _Tp& __t) : __value_(in_place, __t) {}
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit single_view(_Tp&& __t) : __value_(in_place, _VSTD::move(__t)) {}
+    constexpr explicit single_view(_Tp&& __t) : __value_(in_place, std::move(__t)) {}
 
     template<class... _Args>
       requires constructible_from<_Tp, _Args...>
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit single_view(in_place_t, _Args&&... __args)
-      : __value_{in_place, _VSTD::forward<_Args>(__args)...} {}
+      : __value_{in_place, std::forward<_Args>(__args)...} {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr _Tp* begin() noexcept { return data(); }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr const _Tp* begin() const noexcept { return data(); }
 
     _LIBCPP_HIDE_FROM_ABI

libcxx/include/__ranges/size.h

struct __fn {
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(_LIBCPP_AUTO_CAST(size(__t)))) {
       return _LIBCPP_AUTO_CAST(size(__t));
     }
 
     template<__difference _Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(ranges::end(__t) - ranges::begin(__t))) {
-      return _VSTD::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
+      return std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
     }
   };
 } // namespace __size
 
 inline namespace __cpo {
   inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
 } // namespace ranges

libcxx/include/__ranges/subrange.h

namespace ranges {
 
   template<class _Tp>
   concept __pair_like =
     !is_reference_v<_Tp> && requires(_Tp __t) {
       typename tuple_size<_Tp>::type; // Ensures `tuple_size<T>` is complete.
       requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
       typename tuple_element_t<0, remove_const_t<_Tp>>;
       typename tuple_element_t<1, remove_const_t<_Tp>>;
-      { _VSTD::get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
-      { _VSTD::get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
+      { std::get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
+      { std::get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
     };
 
   template<class _Pair, class _Iter, class _Sent>
   concept __pair_like_convertible_from =
     !range<_Pair> && __pair_like<_Pair> &&
     constructible_from<_Pair, _Iter, _Sent> &&
     __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> &&
     convertible_to<_Sent, tuple_element_t<1, _Pair>>;
namespace ranges {
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     subrange() requires default_initializable<_Iter> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
       requires _MustProvideSizeAtConstruction
-      : __begin_(_VSTD::move(__iter)), __end_(_VSTD::move(__sent))
+      : __begin_(std::move(__iter)), __end_(std::move(__sent))
     { }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent,
                        make_unsigned_t<iter_difference_t<_Iter>> __n)
       requires (_Kind == subrange_kind::sized)
-      : __begin_(_VSTD::move(__iter)), __end_(_VSTD::move(__sent)), __size_(__n)
+      : __begin_(std::move(__iter)), __end_(std::move(__sent)), __size_(__n)
     {
       if constexpr (sized_sentinel_for<_Sent, _Iter>)
         _LIBCPP_ASSERT((__end_ - __begin_) == static_cast<iter_difference_t<_Iter>>(__n),
           "std::ranges::subrange was passed an invalid size hint");
     }
 
     template<__different_from<subrange> _Range>
       requires borrowed_range<_Range> &&
public:
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr _Iter begin() const requires copyable<_Iter> {
       return __begin_;
     }
 
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin() requires (!copyable<_Iter>) {
-      return _VSTD::move(__begin_);
+      return std::move(__begin_);
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr _Sent end() const {
       return __end_;
     }
 
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const {
       return __begin_ == __end_;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
       requires (_Kind == subrange_kind::sized)
     {
       if constexpr (_StoreSize)
         return __size_;
       else
-        return _VSTD::__to_unsigned_like(__end_ - __begin_);
+        return std::__to_unsigned_like(__end_ - __begin_);
     }
 
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
       requires forward_iterator<_Iter>
     {
       auto __tmp = *this;
       __tmp.advance(__n);
       return __tmp;
     }
 
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
       advance(__n);
-      return _VSTD::move(*this);
+      return std::move(*this);
     }
 
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
       requires bidirectional_iterator<_Iter>
     {
       auto __tmp = *this;
       __tmp.advance(-__n);
       return __tmp;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr subrange& advance(iter_difference_t<_Iter> __n) {
       if constexpr (bidirectional_iterator<_Iter>) {
         if (__n < 0) {
           ranges::advance(__begin_, __n);
           if constexpr (_StoreSize)
-            __size_ += _VSTD::__to_unsigned_like(-__n);
+            __size_ += std::__to_unsigned_like(-__n);
           return *this;
         }
       }
 
       auto __d = __n - ranges::advance(__begin_, __n, __end_);
       if constexpr (_StoreSize)
-        __size_ -= _VSTD::__to_unsigned_like(__d);
+        __size_ -= std::__to_unsigned_like(__d);
       return *this;
     }
   };
 
   template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
   subrange(_Iter, _Sent) -> subrange<_Iter, _Sent>;
 
   template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>

libcxx/include/__ranges/take_view.h

class take_view : public view_interface<take_view<_View>> {
     template<bool> class __sentinel;
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     take_view() requires default_initializable<_View> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr take_view(_View __base, range_difference_t<_View> __count)
-      : __base_(_VSTD::move(__base)), __count_(__count) {}
+      : __base_(std::move(__base)), __count_(__count) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return _VSTD::move(__base_); }
+    constexpr _View base() && { return std::move(__base_); }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto begin() requires (!__simple_view<_View>) {
       if constexpr (sized_range<_View>) {
         if constexpr (random_access_range<_View>) {
           return ranges::begin(__base_);
         } else {
           using _DifferenceT = range_difference_t<_View>;
constexpr auto end() const requires range<const _View> {
       }
     }
 
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto size() requires sized_range<_View> {
       auto __n = ranges::size(__base_);
       // TODO: use ranges::min here.
-      return _VSTD::min(__n, static_cast<decltype(__n)>(__count_));
+      return std::min(__n, static_cast<decltype(__n)>(__count_));
     }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto size() const requires sized_range<const _View> {
       auto __n = ranges::size(__base_);
       // TODO: use ranges::min here.
-      return _VSTD::min(__n, static_cast<decltype(__n)>(__count_));
+      return std::min(__n, static_cast<decltype(__n)>(__count_));
     }
   };
 
   template<view _View>
   template<bool _Const>
   class take_view<_View>::__sentinel {
     using _Base = __maybe_const<_Const, _View>;
     template<bool _OtherConst>
     using _Iter = counted_iterator<iterator_t<__maybe_const<_OtherConst, _View>>>;
     _LIBCPP_NO_UNIQUE_ADDRESS sentinel_t<_Base> __end_ = sentinel_t<_Base>();
 
     template<bool>
     friend class take_view<_View>::__sentinel;
 
 public:
     _LIBCPP_HIDE_FROM_ABI
     __sentinel() = default;
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(_VSTD::move(__end)) {}
+    constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(std::move(__end)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __sentinel(__sentinel<!_Const> __s)
       requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
-      : __end_(_VSTD::move(__s.__end_)) {}
+      : __end_(std::move(__s.__end_)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr sentinel_t<_Base> base() const { return __end_; }
 
     _LIBCPP_HIDE_FROM_ABI
     friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
       return __lhs.count() == 0 || __lhs.base() == __rhs.__end_;
     }

libcxx/include/__ranges/transform_view.h

 
 public:
   _LIBCPP_HIDE_FROM_ABI
   transform_view()
     requires default_initializable<_View> && default_initializable<_Fn> = default;
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr transform_view(_View __base, _Fn __func)
-    : __func_(_VSTD::in_place, _VSTD::move(__func)), __base_(_VSTD::move(__base)) {}
+    : __func_(std::in_place, std::move(__func)), __base_(std::move(__base)) {}
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
   _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return _VSTD::move(__base_); }
+  constexpr _View base() && { return std::move(__base_); }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<false> begin() {
     return __iterator<false>{*this, ranges::begin(__base_)};
   }
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<true> begin() const
     requires range<const _View> &&
public:
   using value_type = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
   using difference_type = range_difference_t<_Base>;
 
   _LIBCPP_HIDE_FROM_ABI
   __iterator() requires default_initializable<iterator_t<_Base>> = default;
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
-    : __parent_(_VSTD::addressof(__parent)), __current_(_VSTD::move(__current)) {}
+    : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
 
   // Note: `__i` should always be `__iterator<false>`, but directly using
   // `__iterator<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator(__iterator<!_Const> __i)
     requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
-    : __parent_(__i.__parent_), __current_(_VSTD::move(__i.__current_)) {}
+    : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr const iterator_t<_Base>& base() const& noexcept {
     return __current_;
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr iterator_t<_Base> base() && {
-    return _VSTD::move(__current_);
+    return std::move(__current_);
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) operator*() const
-    noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, *__current_)))
+    noexcept(noexcept(std::invoke(*__parent_->__func_, *__current_)))
   {
-    return _VSTD::invoke(*__parent_->__func_, *__current_);
+    return std::invoke(*__parent_->__func_, *__current_);
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator& operator++() {
     ++__current_;
     return *this;
   }
 
constexpr __iterator& operator-=(difference_type __n)
     requires random_access_range<_Base>
   {
     __current_ -= __n;
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr decltype(auto) operator[](difference_type __n) const
-    noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, __current_[__n])))
+    noexcept(noexcept(std::invoke(*__parent_->__func_, __current_[__n])))
     requires random_access_range<_Base>
   {
-    return _VSTD::invoke(*__parent_->__func_, __current_[__n]);
+    return std::invoke(*__parent_->__func_, __current_[__n]);
   }
 
   _LIBCPP_HIDE_FROM_ABI
   friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
     requires equality_comparable<iterator_t<_Base>>
   {
     return __x.__current_ == __y.__current_;
   }
friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
     return __x.__current_ - __y.__current_;
   }
 
   _LIBCPP_HIDE_FROM_ABI
   friend constexpr decltype(auto) iter_move(const __iterator& __i)
     noexcept(noexcept(*__i))
   {
     if constexpr (is_lvalue_reference_v<decltype(*__i)>)
-      return _VSTD::move(*__i);
+      return std::move(*__i);
     else
       return *__i;
   }
 };
 
 template<input_range _View, copy_constructible _Fn>
   requires __transform_view_constraints<_View, _Fn>
 template<bool _Const>
public:
   constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(__end) {}
 
   // Note: `__i` should always be `__sentinel<false>`, but directly using
   // `__sentinel<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
   _LIBCPP_HIDE_FROM_ABI
   constexpr __sentinel(__sentinel<!_Const> __i)
     requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
-    : __end_(_VSTD::move(__i.__end_)) {}
+    : __end_(std::move(__i.__end_)) {}
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr sentinel_t<_Base> base() const { return __end_; }
 
   template<bool _OtherConst>
     requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
   _LIBCPP_HIDE_FROM_ABI
   friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {

 };
 
 namespace views {
 namespace __transform {
   struct __fn {
     template<class _Range, class _Fn>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Range&& __range, _Fn&& __f) const
-      noexcept(noexcept(transform_view(_VSTD::forward<_Range>(__range), _VSTD::forward<_Fn>(__f))))
-      -> decltype(      transform_view(_VSTD::forward<_Range>(__range), _VSTD::forward<_Fn>(__f)))
-      { return          transform_view(_VSTD::forward<_Range>(__range), _VSTD::forward<_Fn>(__f)); }
+      noexcept(noexcept(transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f))))
+      -> decltype(      transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f)))
+      { return          transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f)); }
 
     template<class _Fn>
       requires constructible_from<decay_t<_Fn>, _Fn>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Fn&& __f) const
       noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>)
-    { return __range_adaptor_closure_t(_VSTD::__bind_back(*this, _VSTD::forward<_Fn>(__f))); }
+    { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Fn>(__f))); }
   };
 } // namespace __transform
 
 inline namespace __cpo {
   inline constexpr auto transform = __transform::__fn{};
 } // namespace __cpo
 } // namespace views
 
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H

libcxx/include/__ranges/view_interface.h

constexpr explicit operator bool() const
     requires __can_empty<const _D2>
   {
     return !ranges::empty(__derived());
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto data()
-    noexcept(noexcept(_VSTD::to_address(ranges::begin(__derived()))))
+    noexcept(noexcept(std::to_address(ranges::begin(__derived()))))
     requires contiguous_iterator<iterator_t<_D2>>
   {
-    return _VSTD::to_address(ranges::begin(__derived()));
+    return std::to_address(ranges::begin(__derived()));
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto data() const
-    noexcept(noexcept(_VSTD::to_address(ranges::begin(__derived()))))
+    noexcept(noexcept(std::to_address(ranges::begin(__derived()))))
     requires range<const _D2> && contiguous_iterator<iterator_t<const _D2>>
   {
-    return _VSTD::to_address(ranges::begin(__derived()));
+    return std::to_address(ranges::begin(__derived()));
   }
 
   template<class _D2 = _Derived>
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto size()
     noexcept(noexcept(ranges::end(__derived()) - ranges::begin(__derived())))
     requires forward_range<_D2>
       && sized_sentinel_for<sentinel_t<_D2>, iterator_t<_D2>>