diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst
--- a/libcxx/docs/FeatureTestMacroTable.rst
+++ b/libcxx/docs/FeatureTestMacroTable.rst
@@ -344,7 +344,7 @@
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_starts_ends_with``             *unimplemented*
     ------------------------------------------------- -----------------
-    ``__cpp_lib_ranges_to_container``                 *unimplemented*
+    ``__cpp_lib_ranges_to_container``                 ``202202L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_zip``                          *unimplemented*
     ------------------------------------------------- -----------------
diff --git a/libcxx/docs/Status/Cxx2bPapers.csv b/libcxx/docs/Status/Cxx2bPapers.csv
--- a/libcxx/docs/Status/Cxx2bPapers.csv
+++ b/libcxx/docs/Status/Cxx2bPapers.csv
@@ -41,7 +41,7 @@
 "`P0323R12 <https://wg21.link/P0323R12>`__","LWG","``std::expected``","February 2022","|Complete|","16.0"
 "`P0533R9 <https://wg21.link/P0533R9>`__","LWG","``constexpr`` for ``<cmath>`` and ``<cstdlib>``","February 2022","|In progress| [#note-P0533R9]_",""
 "`P0627R6 <https://wg21.link/P0627R6>`__","LWG","Function to mark unreachable code","February 2022","|Complete|","15.0"
-"`P1206R7 <https://wg21.link/P1206R7>`__","LWG","``ranges::to``: A function to convert any range to a container","February 2022","","","|ranges|"
+"`P1206R7 <https://wg21.link/P1206R7>`__","LWG","``ranges::to``: A function to convert any range to a container","February 2022","|Complete|","16.0","|ranges|"
 "`P1413R3 <https://wg21.link/P1413R3>`__","LWG","Deprecate ``std::aligned_storage`` and ``std::aligned_union``","February 2022","",""
 "`P2255R2 <https://wg21.link/P2255R2>`__","LWG","A type trait to detect reference binding to temporary","February 2022","",""
 "`P2273R3 <https://wg21.link/P2273R3>`__","LWG","Making ``std::unique_ptr`` constexpr","February 2022","|Partial| [#note-P2273]_","16.0"
diff --git a/libcxx/docs/Status/RangesMajorFeatures.csv b/libcxx/docs/Status/RangesMajorFeatures.csv
--- a/libcxx/docs/Status/RangesMajorFeatures.csv
+++ b/libcxx/docs/Status/RangesMajorFeatures.csv
@@ -1,4 +1,4 @@
 Standard,Name,Assignee,CL,Status
-C++23,`ranges::to <https://wg21.link/P1206R7>`_,Unassigned,No patch yet,Not started
+C++23,`ranges::to <https://wg21.link/P1206R7>`_,Konstantin Varlamov,TODO,Complete
 C++23,`Pipe support for user-defined range adaptors <https://wg21.link/P2387R3>`_,Unassigned,No patch yet,Not started
 C++23,`Formatting Ranges <https://wg21.link/P2286R8>`_,Mark de Wever,Various,In progress
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -421,6 +421,7 @@
   __memory/builtin_new_allocator.h
   __memory/compressed_pair.h
   __memory/concepts.h
+  __memory/container_compatible_range.h
   __memory/construct_at.h
   __memory/destruct_n.h
   __memory/pointer_traits.h
@@ -510,6 +511,7 @@
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/filter_view.h
+  __ranges/from_range.h
   __ranges/iota_view.h
   __ranges/istream_view.h
   __ranges/join_view.h
@@ -526,6 +528,7 @@
   __ranges/subrange.h
   __ranges/take_view.h
   __ranges/take_while_view.h
+  __ranges/to.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __ranges/views.h
diff --git a/libcxx/include/__memory/container_compatible_range.h b/libcxx/include/__memory/container_compatible_range.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__memory/container_compatible_range.h
@@ -0,0 +1,35 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_CONTAINER_COMPATIBLE_RANGE_H
+#define _LIBCPP___RANGES_CONTAINER_COMPATIBLE_RANGE_H
+
+#include <__config>
+#include <__concepts/convertible_to.h>
+#include <__ranges/concepts.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Range, class _Tp>
+concept _ContainerCompatibleRange =
+  ranges::input_range<_Range> && convertible_to<ranges::range_reference_t<_Range>, _Tp>;
+
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_CONTAINER_COMPATIBLE_RANGE_H
+
diff --git a/libcxx/include/__ranges/from_range.h b/libcxx/include/__ranges/from_range.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/from_range.h
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_FROM_RANGE_H
+#define _LIBCPP___RANGES_FROM_RANGE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+struct from_range_t {
+  _LIBCPP_HIDE_FROM_ABI explicit from_range_t() = default;
+};
+
+inline constexpr from_range_t from_range{};
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_FROM_RANGE_H
diff --git a/libcxx/include/__ranges/to.h b/libcxx/include/__ranges/to.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/to.h
@@ -0,0 +1,250 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_TO_H
+#define _LIBCPP___RANGES_TO_H
+
+#include <__config>
+#include <__algorithm/ranges_copy.h>
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__functional/bind_back.h>
+#include <__iterator/back_insert_iterator.h>
+#include <__iterator/insert_iterator.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/transform_view.h>
+#include <__ranges/size.h>
+#include <__ranges/range_adaptor.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+// Note: in the current Standard draft, `reservable-container` is a `constexpr bool` variable. However, that doesn't
+// short-circuit which is necessary to avoid trying to evaluate `range_size_t` in case `sized_range` is not satisfied.
+template <class _Container>
+concept __reservable_container = sized_range<_Container> &&
+    requires (_Container& __c, range_size_t<_Container> __n) {
+      __c.reserve(__n);
+      { __c.capacity() } -> same_as<decltype(__n)>;
+      { __c.max_size() } -> same_as<decltype(__n)>;
+    };
+
+template <class _Container, class _Ref>
+constexpr bool __container_insertable =
+  requires (_Container& __c, _Ref&& __ref) {
+    requires (requires { __c.push_back(std::forward<_Ref>(__ref)); } ||
+              // Insufficient constraint: also need to check that inserter(...) is well-formed (the type e.g. must have
+              // begin() defined, have value_type typedef, etc.).
+              requires { __c.insert(__c.end(), std::forward<_Ref>(__ref)); });
+  };
+
+template <class _Ref, class _Container>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __container_inserter(_Container& __c) {
+  if constexpr (requires { __c.push_back(std::declval<_Ref>()); }) {
+    return back_inserter(__c);
+  } else {
+    return inserter(__c, __c.end());
+  }
+}
+
+template <class _Container, class _Range>
+concept __can_try_convert_without_recursion =  !input_range<_Container> ||
+    convertible_to<range_reference_t<_Range>, range_value_t<_Container>>;
+
+template <class>
+concept __false = false;
+
+// `ranges::to` base template -- the `_Container` type is a simple type template parameter.
+template <class _Container, input_range _Range, class... _Args>
+requires (!view<_Container>)
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
+constexpr _Container to(_Range&& __range, _Args&&... __args) {
+  // First see if the non-recursive case applies -- the conversion target is either:
+  // - a range with a convertible value type;
+  // - a non-range type which might support being created from the input argument(s) (e.g. an `optional`).
+  if constexpr (__can_try_convert_without_recursion<_Container, _Range>) {
+
+    // Case 1 -- construct directly from the given range.
+    if constexpr (constructible_from<_Container, _Range, _Args...>) {
+      return _Container(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+    }
+
+    // Case 2 -- construct using the `from_range_t` tagged constructor.
+    else if constexpr (constructible_from<_Container, from_range_t, _Range, _Args...>) {
+      return _Container(from_range, std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+    }
+
+    // Case 3 -- construct from a begin-end iterator pair.
+    else if constexpr (
+        common_range<_Range> &&
+        __iterator_traits_detail::__cpp17_input_iterator<iterator_t<_Range>> &&
+        constructible_from<_Container, iterator_t<_Range>, sentinel_t<_Range>, _Args...>
+    ) {
+      return _Container(ranges::begin(__range), ranges::end(__range), std::forward<_Args>(__args)...);
+    }
+
+    // Case 4 -- default-construct (or construct from the extra arguments) and insert, reserving the size if possible.
+    else if constexpr (
+        constructible_from<_Container, _Args...> &&
+        __container_insertable<_Container, range_reference_t<_Range>>
+    ) {
+      _Container __result(std::forward<_Args>(__args)...);
+      if constexpr (sized_range<_Range> && __reservable_container<_Container>) {
+        __result.reserve(static_cast<range_size_t<_Container>>(ranges::size(__range)));
+      }
+
+      ranges::copy(__range, __container_inserter<range_reference_t<_Range>>(__result));
+
+      return __result;
+
+    } else {
+      static_assert(__false<_Container>, "ranges::to: unable to convert to the given container type.");
+    }
+
+  // Try the recursive case.
+  } else if constexpr (input_range<range_reference_t<_Range>>) {
+    return to<_Container>(__range | views::transform([](auto&& __elem) {
+        return to<range_value_t<_Container>>(std::forward<decltype(__elem)>(__elem));
+      }), std::forward<_Args>(__args)...);
+
+  } else {
+    static_assert(__false<_Container>, "ranges::to: unable to convert to the given container type.");
+  }
+}
+
+template <class _Range>
+struct __minimal_input_iterator {
+  using iterator_category = input_iterator_tag;
+  using value_type = range_value_t<_Range>;
+  using difference_type = ptrdiff_t;
+  using pointer = add_pointer_t<range_reference_t<_Range>>;
+  using reference = range_reference_t<_Range>;
+
+  reference operator*() const;
+  pointer operator->() const;
+  __minimal_input_iterator& operator++();
+  __minimal_input_iterator operator++(int);
+  bool operator==(const __minimal_input_iterator&) const;
+};
+
+// Deduces the full type of the container from the given template template parameter.
+template <template <class...> class _Container, input_range _Range, class... _Args>
+struct _Deducer {
+
+  _LIBCPP_HIDE_FROM_ABI
+   static constexpr auto __deduce_func() {
+    using _InputIter = __minimal_input_iterator<_Range>;
+
+    // Case 1 -- can construct directly from the given range.
+    if constexpr (true || requires {
+        _Container(std::declval<_Range>(), std::declval<_Args>()...);
+    }) {
+      using _Result = decltype( //
+        _Container(std::declval<_Range>(), std::declval<_Args>()...));
+      return (_Result*){};
+
+    // Case 2 -- can construct from the given range using the `from_range_t` tagged constructor.
+    } else if constexpr (requires {
+        _Container(from_range, std::declval<_Range>(), std::declval<_Args>()...);
+    }) {
+      using _Result = decltype( //
+        _Container(from_range, std::declval<_Range>(), std::declval<_Args>()...));
+      return (_Result*){};
+
+    // Case 3 -- can construct from a begin-end iterator pair.
+    } else if constexpr (requires {
+        _Container(std::declval<_InputIter>(), std::declval<_InputIter>(), std::declval<_Args>()...);
+    }) {
+      using _Result = decltype( //
+        _Container(std::declval<_InputIter>(), std::declval<_InputIter>(), std::declval<_Args>()...));
+      return (_Result*){};
+
+    } else {
+      static_assert(__false<_Range>,
+          "ranges::to: unable to deduce the container type from the template template argument.");
+    }
+  }
+
+  using type = remove_pointer_t<decltype(__deduce_func())>;
+
+};
+
+// `ranges::to` specialization -- `_Container` is a template template parameter requiring deduction to figure out the
+// container element type.
+template <template <class...> class _Container, input_range _Range, class... _Args>
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
+constexpr auto to(_Range&& __range, _Args&&... __args) {
+  using _DeduceExpr = typename _Deducer<_Container, _Range, _Args...>::type;
+  return to<_DeduceExpr>(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+}
+
+template <class _Container>
+struct __to_nondeduced {
+
+  template <input_range _Range, class... _Args>
+  constexpr _Container operator()(_Range&& __range, _Args&&... __args) const
+  requires requires {
+    /*  */ ranges::to<_Container>(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+  } {
+    return ranges::to<_Container>(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+  }
+
+};
+
+// Range adaptor closure object 1 -- wrapping the `ranges::to` version where `_Container` is a simple type template
+// parameter.
+template <class _Container, class... _Args>
+requires (!view<_Container>)
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
+constexpr auto to(_Args&&... __args) {
+  return __range_adaptor_closure_t(
+      std::__bind_back(__to_nondeduced<_Container>(), std::forward<_Args>(__args)...));
+}
+
+template <template <class...> class _Container>
+struct __to_deduced {
+
+  template <input_range _Range, class... _Args,
+            class _DeducedExpr = typename _Deducer<_Container, _Range, _Args...>::type>
+  constexpr auto operator()(_Range&& __range, _Args&&... __args) const
+  requires requires {
+    /*  */ ranges::to<_Container<_DeducedExpr>>(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+  } {
+    return ranges::to<_Container<_DeducedExpr>>(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+  }
+
+};
+
+// Range adaptor closure object 2 -- wrapping the `ranges::to` version where `_Container` is a template template
+// parameter.
+template <template <class...> class _Container, class... _Args>
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
+constexpr auto to(_Args&&... __args) {
+  return __range_adaptor_closure_t(
+      std::__bind_back(__to_deduced<_Container>(), std::forward<_Args>(__args)...));
+}
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_TO_H
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -1068,6 +1068,7 @@
       module builtin_new_allocator           { private header "__memory/builtin_new_allocator.h" }
       module compressed_pair                 { private header "__memory/compressed_pair.h" }
       module concepts                        { private header "__memory/concepts.h" }
+      module container_compatible_range      { private header "__memory/container_compatible_range.h" }
       module construct_at                    { private header "__memory/construct_at.h" }
       module destruct_n                      { private header "__memory/destruct_n.h" }
       module pointer_traits                  { private header "__memory/pointer_traits.h" }
@@ -1235,6 +1236,7 @@
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h" }
       module filter_view            { private header "__ranges/filter_view.h" }
+      module from_range             { private header "__ranges/from_range.h" }
       module iota_view              { private header "__ranges/iota_view.h" }
       module istream_view           {
         @requires_LIBCXX_ENABLE_LOCALIZATION@
@@ -1258,6 +1260,7 @@
       }
       module take_view              { private header "__ranges/take_view.h" }
       module take_while_view        { private header "__ranges/take_while_view.h" }
+      module to                     { private header "__ranges/to.h" }
       module transform_view         {
         private header "__ranges/transform_view.h"
         export functional.__functional.bind_back
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -136,6 +136,16 @@
     inline constexpr auto values = elements<1>;
   }
 
+  // [range.utility.conv], range conversions
+  template<class C, input_range R, class... Args> requires (!view<C>)
+    constexpr C to(R&& r, Args&&... args);     // Since C++23
+  template<template<class...> class C, input_range R, class... Args>
+    constexpr auto to(R&& r, Args&&... args);  // Since C++23
+  template<class C, class... Args> requires (!view<C>)
+    constexpr auto to(Args&&... args);         // Since C++23
+  template<template<class...> class C, class... Args>
+    constexpr auto to(Args&&... args);         // Since C++23
+
   // [range.empty], empty view
   template<class T>
     requires is_object_v<T>
@@ -323,6 +333,9 @@
   struct tuple_element<1, const ranges::subrange<I, S, K>> {
     using type = S;
   };
+
+  struct from_range_t { explicit from_range_t() = default; };  // Since C++23
+  inline constexpr from_range_t from_range{};                  // Since C++23
 }
 */
 
@@ -343,6 +356,7 @@
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/filter_view.h>
+#include <__ranges/from_range.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/lazy_split_view.h>
@@ -355,6 +369,7 @@
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>
 #include <__ranges/take_while_view.h>
+#include <__ranges/to.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <__ranges/views.h>
diff --git a/libcxx/include/vector b/libcxx/include/vector
--- a/libcxx/include/vector
+++ b/libcxx/include/vector
@@ -41,6 +41,8 @@
     vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
     template <class InputIterator>
         vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
+    template<container-compatible-range<T> R>
+      constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
     vector(const vector& x);
     vector(vector&& x)
         noexcept(is_nothrow_move_constructible<allocator_type>::value);
@@ -247,6 +249,10 @@
    vector(InputIterator, InputIterator, Allocator = Allocator())
    -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+  vector(from_range_t, R&&, Allocator = Allocator())
+    -> vector<ranges::range_value_t<R>, Allocator>; // C++23
+
 template <class Allocator> struct hash<std::vector<bool, Allocator>>;
 
 template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
@@ -291,11 +297,16 @@
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
+#include <__memory/container_compatible_range.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory/temp_value.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/from_range.h>
+#include <__ranges/size.h>
 #include <__split_buffer>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/noexcept_move_assign_container.h>
@@ -424,6 +435,30 @@
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
   vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a);
 
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr vector(from_range_t, _Range&& __range,
+      const allocator_type& __alloc = allocator_type()) : __end_cap_(nullptr, __alloc) {
+    auto __guard = std::__make_transaction(__destroy_vector(*this));
+    std::__debug_db_insert_c(this);
+
+    if constexpr (ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::size(__range));
+      if (__n > 0) {
+          __vallocate(__n);
+          __construct_at_end(ranges::begin(__range), ranges::end(__range), __n);
+      }
+
+    } else {
+      for (auto&& __e : __range) {
+        emplace_back(std::forward<decltype(__e)>(__e));
+      }
+    }
+
+    __guard.__complete();
+  }
+#endif
+
 private:
   class __destroy_vector {
     public:
@@ -689,9 +724,9 @@
     _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
     void __construct_at_end(size_type __n, const_reference __x);
 
-  template <class _ForwardIterator, __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value, int> = 0>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
-  __construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n);
+  template <class _ForwardIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  void __construct_at_end(_ForwardIterator __first, _Sentinel __last, size_type __n);
 
     _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
     _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const_reference __x);
@@ -898,6 +933,14 @@
   -> vector<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+
+template< ranges::input_range _Range, class _Allocator = allocator<ranges::range_value_t<_Range>>>
+    vector(from_range_t, _Range&&, _Allocator = _Allocator())
+      -> vector<ranges::range_value_t<_Range>, _Allocator>;
+
+#endif
+
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
@@ -1012,10 +1055,13 @@
 }
 
 template <class _Tp, class _Allocator>
-template <class _ForwardIterator, __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value, int> >
+template <class _ForwardIterator, class _Sentinel>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n)
+vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _Sentinel __last, size_type __n)
 {
+  static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
+      "The iterator type must be at least a forward iterator.");
+
   _ConstructTransaction __tx(*this, __n);
   __tx.__pos_ = std::__uninitialized_allocator_copy(__alloc(), __first, __last, __tx.__pos_);
 }
@@ -2346,13 +2392,9 @@
         {return (__new_size + (__bits_per_word-1)) & ~((size_type)__bits_per_word-1);}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20  size_type __recommend(size_type __new_size) const;
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_at_end(size_type __n, bool __x);
-    template <class _ForwardIterator>
-        typename enable_if
-        <
-            __is_cpp17_forward_iterator<_ForwardIterator>::value,
-            void
-        >::type
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
+    template <class _ForwardIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __construct_at_end(_ForwardIterator __first, _Sentinel __last, size_type __n);
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __append(size_type __n, const_reference __x);
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     reference __make_ref(size_type __pos) _NOEXCEPT
@@ -2482,17 +2524,15 @@
 }
 
 template <class _Allocator>
-template <class _ForwardIterator>
+template <class _ForwardIterator, class _Sentinel>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __is_cpp17_forward_iterator<_ForwardIterator>::value,
-    void
->::type
-vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
+void vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _Sentinel __last, size_type __n)
 {
+    static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
+        "The iterator type must be at least a forward iterator.");
+
     size_type __old_size = this->__size_;
-    this->__size_ += std::distance(__first, __last);
+    this->__size_ += __n;
     if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word))
     {
         if (this->__size_ <= __bits_per_word)
@@ -2500,7 +2540,7 @@
         else
             this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
     }
-    std::copy(__first, __last, __make_iter(__old_size));
+    std::__copy<_ClassicAlgPolicy>(__first, __last, __make_iter(__old_size));
 }
 
 template <class _Allocator>
@@ -2653,7 +2693,7 @@
     if (__n > 0)
     {
         __vallocate(__n);
-        __construct_at_end(__first, __last);
+        __construct_at_end(__first, __last, __n);
     }
     __guard.__complete();
 }
@@ -2672,7 +2712,7 @@
     if (__n > 0)
     {
         __vallocate(__n);
-        __construct_at_end(__first, __last);
+        __construct_at_end(__first, __last, __n);
     }
     __guard.__complete();
 }
@@ -2690,7 +2730,7 @@
     if (__n > 0)
     {
         __vallocate(__n);
-        __construct_at_end(__il.begin(), __il.end());
+        __construct_at_end(__il.begin(), __il.end(), __n);
     }
 }
 
@@ -2705,7 +2745,7 @@
     if (__n > 0)
     {
         __vallocate(__n);
-        __construct_at_end(__il.begin(), __il.end());
+        __construct_at_end(__il.begin(), __il.end(), __n);
     }
 }
 
@@ -2721,7 +2761,7 @@
     if (__v.size() > 0)
     {
         __vallocate(__v.size());
-        __construct_at_end(__v.begin(), __v.end());
+        __construct_at_end(__v.begin(), __v.end(), __v.size());
     }
 }
 
@@ -2735,7 +2775,7 @@
     if (__v.size() > 0)
     {
         __vallocate(__v.size());
-        __construct_at_end(__v.begin(), __v.end());
+        __construct_at_end(__v.begin(), __v.end(), __v.size());
     }
 }
 
@@ -2794,7 +2834,7 @@
     else if (__v.size() > 0)
     {
         __vallocate(__v.size());
-        __construct_at_end(__v.begin(), __v.end());
+        __construct_at_end(__v.begin(), __v.end(), __v.size());
     }
 }
 
@@ -2888,7 +2928,7 @@
             __vdeallocate();
             __vallocate(__n);
         }
-        __construct_at_end(__first, __last);
+        __construct_at_end(__first, __last, __n);
     }
 }
 
@@ -2902,7 +2942,7 @@
             this->__throw_length_error();
         vector __v(this->get_allocator());
         __v.__vallocate(__n);
-        __v.__construct_at_end(this->begin(), this->end());
+        __v.__construct_at_end(this->begin(), this->end(), __n);
         swap(__v);
         std::__debug_db_invalidate_all(this);
     }
diff --git a/libcxx/include/version b/libcxx/include/version
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -407,7 +407,7 @@
 // # define __cpp_lib_ranges_join_with                     202202L
 // # define __cpp_lib_ranges_slide                         202202L
 // # define __cpp_lib_ranges_starts_ends_with              202106L
-// # define __cpp_lib_ranges_to_container                  202202L
+# define __cpp_lib_ranges_to_container                  202202L
 // # define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -453,6 +453,7 @@
 #include <__memory/compressed_pair.h> // expected-error@*:* {{use of private header from outside its module: '__memory/compressed_pair.h'}}
 #include <__memory/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__memory/concepts.h'}}
 #include <__memory/construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/construct_at.h'}}
+#include <__memory/container_compatible_range.h> // expected-error@*:* {{use of private header from outside its module: '__memory/container_compatible_range.h'}}
 #include <__memory/destruct_n.h> // expected-error@*:* {{use of private header from outside its module: '__memory/destruct_n.h'}}
 #include <__memory/pointer_traits.h> // expected-error@*:* {{use of private header from outside its module: '__memory/pointer_traits.h'}}
 #include <__memory/ranges_construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/ranges_construct_at.h'}}
@@ -541,6 +542,7 @@
 #include <__ranges/enable_borrowed_range.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/enable_borrowed_range.h'}}
 #include <__ranges/enable_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/enable_view.h'}}
 #include <__ranges/filter_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/filter_view.h'}}
+#include <__ranges/from_range.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/from_range.h'}}
 #include <__ranges/iota_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/iota_view.h'}}
 #include <__ranges/istream_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/istream_view.h'}}
 #include <__ranges/join_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/join_view.h'}}
@@ -557,6 +559,7 @@
 #include <__ranges/subrange.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/subrange.h'}}
 #include <__ranges/take_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_view.h'}}
 #include <__ranges/take_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_while_view.h'}}
+#include <__ranges/to.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/to.h'}}
 #include <__ranges/transform_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/transform_view.h'}}
 #include <__ranges/view_interface.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/view_interface.h'}}
 #include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/deque.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/deque.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/deque.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/deque.version.compile.pass.cpp
@@ -135,17 +135,11 @@
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should be defined in c++2b"
-#   endif
-#   if __cpp_lib_ranges_to_container != 202202L
-#     error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should be defined in c++2b"
+# endif
+# if __cpp_lib_ranges_to_container != 202202L
+#   error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
 # endif
 
 #endif // TEST_STD_VER > 20
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/list.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/list.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/list.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/list.version.compile.pass.cpp
@@ -192,17 +192,11 @@
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should be defined in c++2b"
-#   endif
-#   if __cpp_lib_ranges_to_container != 202202L
-#     error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should be defined in c++2b"
+# endif
+# if __cpp_lib_ranges_to_container != 202202L
+#   error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
 # endif
 
 #endif // TEST_STD_VER > 20
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/stack.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/stack.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/stack.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/stack.version.compile.pass.cpp
@@ -72,17 +72,11 @@
 #   error "__cpp_lib_adaptor_iterator_pair_constructor should have the value 202106L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should be defined in c++2b"
-#   endif
-#   if __cpp_lib_ranges_to_container != 202202L
-#     error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should be defined in c++2b"
+# endif
+# if __cpp_lib_ranges_to_container != 202202L
+#   error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
 # endif
 
 #endif // TEST_STD_VER > 20
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/string.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/string.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/string.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/string.version.compile.pass.cpp
@@ -305,17 +305,11 @@
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should be defined in c++2b"
-#   endif
-#   if __cpp_lib_ranges_to_container != 202202L
-#     error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should be defined in c++2b"
+# endif
+# if __cpp_lib_ranges_to_container != 202202L
+#   error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
 # endif
 
 # ifndef __cpp_lib_starts_ends_with
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/unordered_map.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/unordered_map.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/unordered_map.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/unordered_map.version.compile.pass.cpp
@@ -245,17 +245,11 @@
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should be defined in c++2b"
-#   endif
-#   if __cpp_lib_ranges_to_container != 202202L
-#     error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should be defined in c++2b"
+# endif
+# if __cpp_lib_ranges_to_container != 202202L
+#   error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
 # endif
 
 # ifndef __cpp_lib_unordered_map_try_emplace
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
@@ -4583,17 +4583,11 @@
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should be defined in c++2b"
-#   endif
-#   if __cpp_lib_ranges_to_container != 202202L
-#     error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_ranges_to_container
-#     error "__cpp_lib_ranges_to_container should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should be defined in c++2b"
+# endif
+# if __cpp_lib_ranges_to_container != 202202L
+#   error "__cpp_lib_ranges_to_container should have the value 202202L in c++2b"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
diff --git a/libcxx/test/std/ranges/range.utility/range.utility.conv/to.pass.cpp b/libcxx/test/std/ranges/range.utility/range.utility.conv/to.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.utility/range.utility.conv/to.pass.cpp
@@ -0,0 +1,373 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<class C, input_range R, class... Args> requires (!view<C>)
+//   constexpr C to(R&& r, Args&&... args);     // Since C++23
+// template<template<class...> class C, input_range R, class... Args>
+//   constexpr auto to(R&& r, Args&&... args);  // Since C++23
+
+#include <ranges>
+
+#include <algorithm>
+#include <cassert>
+#include "test_iterators.h"
+
+#include <array>
+#include <vector>
+
+// - Helper concepts
+// - Constraints + fail tests
+//
+// - Deducing
+// - Adaptors
+//
+// - Standard containers
+
+enum class CtrChoice {
+  Invalid,
+  DefaultCtrAndInsert,
+  BeginEndPair,
+  FromRangeT,
+  DirectCtr
+};
+
+enum class InserterChoice {
+  Invalid,
+  Insert,
+  PushBack
+};
+
+template <class ElementType, CtrChoice Rank, InserterChoice Inserter = InserterChoice::Insert, bool CanReserve = false>
+struct Container {
+  CtrChoice ctr_choice = CtrChoice::Invalid;
+  InserterChoice inserter_choice = InserterChoice::Invalid;
+  bool called_reserve = false;
+
+  int extra_arg1 = 0;
+  char extra_arg2 = 0;
+
+  using value_type = ElementType;
+  static constexpr int Capacity = 8;
+  int size_ = 0;
+  ElementType buffer_[Capacity] = {};
+
+  // Case 1 -- construct directly from the range.
+
+  constexpr explicit Container(std::ranges::input_range auto&& in)
+  requires (Rank >= CtrChoice::DirectCtr)
+    : ctr_choice(CtrChoice::DirectCtr), size_(std::ranges::size(in)) {
+    std::ranges::copy(in, begin());
+  }
+
+  constexpr explicit Container(std::ranges::input_range auto&& in, int arg1, char arg2)
+  requires (Rank >= CtrChoice::DirectCtr)
+    : Container(in) {
+    extra_arg1 = arg1;
+    extra_arg2 = arg2;
+  }
+
+  // Case 2 -- use `from_range_t` constructor.
+
+  constexpr Container(std::from_range_t, std::ranges::input_range auto&& in)
+  requires (Rank >= CtrChoice::FromRangeT)
+    : ctr_choice(CtrChoice::FromRangeT), size_(std::ranges::size(in)) {
+    std::ranges::copy(in, begin());
+  }
+
+  constexpr Container(std::from_range_t, std::ranges::input_range auto&& in, int arg1, char arg2)
+  requires (Rank >= CtrChoice::FromRangeT)
+    : Container(std::from_range, in) {
+    extra_arg1 = arg1;
+    extra_arg2 = arg2;
+  }
+
+  // Case 3 -- use begin-end pair.
+
+  template <class Iter>
+  constexpr Container(Iter b, Iter e)
+  requires (Rank >= CtrChoice::BeginEndPair)
+    : ctr_choice(CtrChoice::BeginEndPair), size_(e - b) {
+    std::ranges::copy(b, e, begin());
+  }
+
+  template <class Iter>
+  constexpr Container(Iter b, Iter e, int arg1, char arg2)
+  requires (Rank >= CtrChoice::BeginEndPair)
+    : Container(b, e) {
+    extra_arg1 = arg1;
+    extra_arg2 = arg2;
+  }
+
+  // Case 4 -- default-construct and insert, reserving the size if possible.
+
+  constexpr Container()
+  requires  (Rank >= CtrChoice::DefaultCtrAndInsert)
+    : ctr_choice(CtrChoice::DefaultCtrAndInsert) {}
+
+  constexpr Container(int arg1, char arg2)
+  requires  (Rank >= CtrChoice::DefaultCtrAndInsert)
+    : ctr_choice(CtrChoice::DefaultCtrAndInsert), extra_arg1(arg1), extra_arg2(arg2) {}
+
+  constexpr ElementType* begin() { return buffer_; }
+  constexpr ElementType* end() { return buffer_ + size_; }
+  constexpr size_t size() const { return size_; }
+
+  template <class T>
+  constexpr void push_back(T val)
+  requires  (Inserter >= InserterChoice::PushBack)
+  {
+    inserter_choice = InserterChoice::PushBack;
+    buffer_[size_] = val;
+    ++size_;
+  }
+
+  template <class T>
+  constexpr ElementType* insert(ElementType* where, T val)
+  requires  (Inserter >= InserterChoice::Insert)
+  {
+    inserter_choice = InserterChoice::Insert;
+
+    auto where_index = where - begin();
+    for (int i = Capacity - 2; i >= where_index; --i) {
+      buffer_[i + 1] = buffer_[i];
+    }
+    *where = val;
+    ++size_;
+
+    return where;
+  }
+
+  constexpr void reserve(size_t)
+  requires CanReserve
+  {
+    called_reserve = true;
+  }
+
+  constexpr size_t capacity() const
+  requires CanReserve
+  { return Capacity; }
+
+  constexpr size_t max_size() const
+  requires CanReserve
+  { return Capacity; }
+
+};
+
+constexpr void test_ctr_choice_order() {
+  std::array in = {1, 2, 3, 4, 5};
+  int arg1 = 42;
+  char arg2 = 'a';
+
+  { // Case 1 -- construct directly from the given range.
+    {
+      using C = Container<int, CtrChoice::DirectCtr>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+
+      assert(result.ctr_choice == CtrChoice::DirectCtr);
+      assert(std::ranges::equal(result, in));
+    }
+
+    { // Extra arguments.
+      using C = Container<int, CtrChoice::DirectCtr>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in, arg1, arg2);
+
+      assert(result.ctr_choice == CtrChoice::DirectCtr);
+      assert(std::ranges::equal(result, in));
+      assert(result.extra_arg1 == arg1);
+      assert(result.extra_arg2 == arg2);
+    }
+  }
+
+  { // Case 2 -- construct using the `from_range_t` tag.
+    {
+      using C = Container<int, CtrChoice::FromRangeT>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+
+      assert(result.ctr_choice == CtrChoice::FromRangeT);
+      assert(std::ranges::equal(result, in));
+    }
+
+    { // Extra arguments.
+      using C = Container<int, CtrChoice::FromRangeT>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in, arg1, arg2);
+
+      assert(result.ctr_choice == CtrChoice::FromRangeT);
+      assert(std::ranges::equal(result, in));
+      assert(result.extra_arg1 == arg1);
+      assert(result.extra_arg2 == arg2);
+    }
+  }
+
+  { // Case 3 -- construct from a begin-end pair.
+    {
+      using C = Container<int, CtrChoice::BeginEndPair>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+
+      assert(result.ctr_choice == CtrChoice::BeginEndPair);
+      assert(std::ranges::equal(result, in));
+    }
+
+    { // Extra arguments.
+      using C = Container<int, CtrChoice::BeginEndPair>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in, arg1, arg2);
+
+      assert(result.ctr_choice == CtrChoice::BeginEndPair);
+      assert(std::ranges::equal(result, in));
+      assert(result.extra_arg1 == arg1);
+      assert(result.extra_arg2 == arg2);
+    }
+  }
+
+  { // Case 4 -- default-construct then insert elements.
+    {
+      using C = Container<int, CtrChoice::DefaultCtrAndInsert, InserterChoice::Insert, /*CanReserve=*/false>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+      assert(result.inserter_choice == InserterChoice::Insert);
+      assert(std::ranges::equal(result, in));
+      assert(!result.called_reserve);
+    }
+
+    {
+      using C = Container<int, CtrChoice::DefaultCtrAndInsert, InserterChoice::Insert, /*CanReserve=*/true>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+      assert(result.inserter_choice == InserterChoice::Insert);
+      assert(std::ranges::equal(result, in));
+      assert(result.called_reserve);
+    }
+
+    {
+      using C = Container<int, CtrChoice::DefaultCtrAndInsert, InserterChoice::PushBack, /*CanReserve=*/false>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+      assert(result.inserter_choice == InserterChoice::PushBack);
+      assert(std::ranges::equal(result, in));
+      assert(!result.called_reserve);
+    }
+
+    {
+      using C = Container<int, CtrChoice::DefaultCtrAndInsert, InserterChoice::PushBack, /*CanReserve=*/true>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+      assert(result.inserter_choice == InserterChoice::PushBack);
+      assert(std::ranges::equal(result, in));
+      assert(result.called_reserve);
+    }
+
+    { // Extra arguments.
+      using C = Container<int, CtrChoice::DefaultCtrAndInsert, InserterChoice::Insert, /*CanReserve=*/false>;
+      std::same_as<C> decltype(auto) result = std::ranges::to<C>(in, arg1, arg2);
+
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+      assert(result.inserter_choice == InserterChoice::Insert);
+      assert(std::ranges::equal(result, in));
+      assert(!result.called_reserve);
+      assert(result.extra_arg1 == arg1);
+      assert(result.extra_arg2 == arg2);
+    }
+  }
+}
+
+template <CtrChoice Rank>
+struct NotARange {
+  constexpr NotARange(std::ranges::input_range auto&&)
+  requires (Rank >= CtrChoice::DirectCtr)
+  {}
+
+  constexpr NotARange(std::from_range_t, std::ranges::input_range auto&&)
+  requires (Rank >= CtrChoice::FromRangeT)
+  {}
+};
+
+static_assert(!std::ranges::range<NotARange<CtrChoice::DirectCtr>>);
+
+constexpr void test_lwg_3785() {
+  // Test LWG 3785 ("`ranges::to` is over-constrained on the destination type being a range") -- make sure it's possible
+  // to convert the given input range to a non-range type.
+  std::array in = {1, 2, 3, 4, 5};
+
+  {
+    using C = NotARange<CtrChoice::DirectCtr>;
+    [[maybe_unused]] std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+  }
+
+  {
+    using C = NotARange<CtrChoice::FromRangeT>;
+    [[maybe_unused]] std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+  }
+}
+
+constexpr void test_recursive() {
+  using C1 = Container<int, CtrChoice::DirectCtr>;
+  using C2 = Container<C1, CtrChoice::FromRangeT>;
+  using C3 = Container<C2, CtrChoice::BeginEndPair>;
+  using C4 = Container<C3, CtrChoice::DefaultCtrAndInsert, InserterChoice::PushBack>;
+  using A1 = std::array<int, 4>;
+  using A2 = std::array<A1, 3>;
+  using A3 = std::array<A2, 2>;
+  using A4 = std::array<A3, 2>;
+
+  A4 in = {};
+  std::same_as<C4> decltype(auto) result = std::ranges::to<C4>(in);
+
+  assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+  for (auto& c3 : result) {
+    assert(c3.ctr_choice == CtrChoice::BeginEndPair);
+
+    for (auto& c2 : c3) {
+      assert(c2.ctr_choice == CtrChoice::FromRangeT);
+
+      for (auto& c1 : c2) {
+        assert(c1.ctr_choice == CtrChoice::DirectCtr);
+      }
+    }
+  }
+}
+
+constexpr void test_deduce_expr() {
+  { // Case 1 -- can construct directly from the given range.
+  }
+
+  { // Case 2 -- can construct from the given range using the `from_range_t` tagged constructor.
+  }
+
+  { // Case 3 -- can construct from a begin-end iterator pair.
+  }
+}
+
+constexpr bool test() {
+  test_ctr_choice_order();
+  test_lwg_3785();
+  test_recursive();
+  test_deduce_expr();
+
+  ////////////////////////////////////////////////////////////////////////////////
+  {
+    std::vector<int> v1 = {1, 2, 3, 4, 5};
+    std::vector<int> v2 = std::ranges::to<std::vector<int>>(v1);
+    assert(v1 == v2);
+    std::vector<int> v3 = std::ranges::to<std::vector>(v1);
+    assert(v1 == v3);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -570,7 +570,6 @@
     "name": "__cpp_lib_ranges_to_container",
     "values": { "c++2b": 202202 },
     "headers": ["deque", "forward_list", "list", "map", "priority_queue", "queue", "set", "stack", "string", "unordered_map", "unordered_set", "vector"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_zip",
     "values": { "c++2b": 202110 },