diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst
--- a/libcxx/docs/FeatureTestMacroTable.rst
+++ b/libcxx/docs/FeatureTestMacroTable.rst
@@ -352,7 +352,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/ReleaseNotes.rst b/libcxx/docs/ReleaseNotes.rst
--- a/libcxx/docs/ReleaseNotes.rst
+++ b/libcxx/docs/ReleaseNotes.rst
@@ -37,6 +37,7 @@
 
 Implemented Papers
 ------------------
+- P1206R7 - ``ranges::to``: A function to convert any range to a container
 - P2520R0 - ``move_iterator<T*>`` should be a random access iterator
 - P1328R1 - ``constexpr type_info::operator==()``
 - P1413R3 - Formatting ``thread::id`` (the ``stacktrace`` is not done yet)
diff --git a/libcxx/docs/Status/Cxx2bIssues.csv b/libcxx/docs/Status/Cxx2bIssues.csv
--- a/libcxx/docs/Status/Cxx2bIssues.csv
+++ b/libcxx/docs/Status/Cxx2bIssues.csv
@@ -258,7 +258,7 @@
 "`3820 <https://wg21.link/LWG3820>`__","``cartesian_product_view::iterator::prev`` is not quite right","February 2023","","","|ranges|"
 "`3825 <https://wg21.link/LWG3825>`__","Missing compile-time argument ``id`` check in ``basic_format_parse_context::next_arg_id``","February 2023","|Complete|","17.0","|format|"
 "`3204 <https://wg21.link/LWG3204>`__","``sub_match::swap`` only swaps the base class","February 2023","|Complete|","17.0",""
-"`3733 <https://wg21.link/LWG3733>`__","``ranges::to`` misuses ``cpp17-input-iterator``","February 2023","","","|ranges|"
+"`3733 <https://wg21.link/LWG3733>`__","``ranges::to`` misuses ``cpp17-input-iterator``","February 2023","|Complete|","17.0","|ranges|"
 "`3742 <https://wg21.link/LWG3742>`__","``deque::prepend_range`` needs to permute","February 2023","","","|ranges|"
 "`3790 <https://wg21.link/LWG3790>`__","`P1467 <https://wg21.link/P1467>`__ accidentally changed ``nexttoward``'s signature","February 2023","","",""
 "`3819 <https://wg21.link/LWG3819>`__","``reference_meows_from_temporary`` should not use ``is_meowible``","February 2023","","",""
@@ -292,7 +292,7 @@
 "`3833 <https://wg21.link/LWG3833>`__","Remove specialization ``template<size_t N> struct formatter<const charT[N], charT>``","February 2023","|Complete|","17.0","|format|"
 "`3836 <https://wg21.link/LWG3836>`__","``std::expected<bool, E1>`` conversion constructor ``expected(const expected<U, G>&)`` should take precedence over ``expected(U&&)`` with operator ``bool``","February 2023","","",""
 "`3843 <https://wg21.link/LWG3843>`__","``std::expected<T,E>::value() &`` assumes ``E`` is copy constructible","February 2023","","",""
-"`3847 <https://wg21.link/LWG3847>`__","``ranges::to`` can still return views","February 2023","","","|ranges|"
+"`3847 <https://wg21.link/LWG3847>`__","``ranges::to`` can still return views","February 2023","|Complete|","17.0","|ranges|"
 "`3862 <https://wg21.link/LWG3862>`__","``basic_const_iterator``'s ``common_type`` specialization is underconstrained","February 2023","","",""
 "`3865 <https://wg21.link/LWG3865>`__","Sorting a range of ``pairs``","February 2023","|Complete|","17.0","|ranges|"
 "`3869 <https://wg21.link/LWG3869>`__","Deprecate ``std::errc`` constants related to UNIX STREAMS","February 2023","","",""
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|","17.0","|ranges|"
 "`P1413R3 <https://wg21.link/P1413R3>`__","LWG","Deprecate ``std::aligned_storage`` and ``std::aligned_union``","February 2022","|Complete| [#note-P1413R3]_",""
 "`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","|Complete|","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,`D142335 <https://reviews.llvm.org/D142335>`_,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,Complete
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -438,6 +438,7 @@
   __iterator/permutable.h
   __iterator/prev.h
   __iterator/projected.h
+  __iterator/ranges_iterator_traits.h
   __iterator/readable_traits.h
   __iterator/reverse_access.h
   __iterator/reverse_iterator.h
@@ -581,6 +582,7 @@
   __ranges/as_rvalue_view.h
   __ranges/common_view.h
   __ranges/concepts.h
+  __ranges/container_compatible_range.h
   __ranges/copyable_box.h
   __ranges/counted.h
   __ranges/dangling.h
@@ -593,6 +595,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
@@ -610,6 +613,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/__algorithm/copy_n.h b/libcxx/include/__algorithm/copy_n.h
--- a/libcxx/include/__algorithm/copy_n.h
+++ b/libcxx/include/__algorithm/copy_n.h
@@ -10,10 +10,13 @@
 #define _LIBCPP___ALGORITHM_COPY_N_H
 
 #include <__algorithm/copy.h>
+#include <__algorithm/iterator_operations.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__type_traits/enable_if.h>
 #include <__utility/convert_to_integral.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -21,45 +24,53 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _InputIterator, class _Size, class _OutputIterator>
+template <class _AlgPolicy, class _InputIterator, class _Size, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename enable_if
 <
     __is_cpp17_input_iterator<_InputIterator>::value &&
    !__is_cpp17_random_access_iterator<_InputIterator>::value,
-    _OutputIterator
+    pair<_InputIterator, _OutputIterator>
 >::type
-copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
+__copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 {
     typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
     _IntegralSize __n = __orig_n;
     if (__n > 0)
     {
         *__result = *__first;
+        ++__first;
         ++__result;
         for (--__n; __n > 0; --__n)
         {
-            ++__first;
             *__result = *__first;
+            ++__first;
             ++__result;
         }
     }
-    return __result;
+    return std::make_pair(std::move(__first), std::move(__result));
 }
 
-template<class _InputIterator, class _Size, class _OutputIterator>
+template <class _AlgPolicy, class _InputIterator, class _Size, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename enable_if
 <
     __is_cpp17_random_access_iterator<_InputIterator>::value,
-    _OutputIterator
+    pair<_InputIterator, _OutputIterator>
 >::type
-copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
+__copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 {
-    typedef typename iterator_traits<_InputIterator>::difference_type difference_type;
+    using difference_type = typename _IterOps<_AlgPolicy>:: template __difference_type<_InputIterator>;
     typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
     _IntegralSize __n = __orig_n;
-    return _VSTD::copy(__first, __first + difference_type(__n), __result);
+    return std::__copy<_AlgPolicy>(__first, __first + difference_type(__n), __result);
+}
+
+template<class _InputIterator, class _Size, class _OutputIterator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+_OutputIterator copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
+{
+  return std::__copy_n<_ClassicAlgPolicy>(std::move(__first), __n, std::move(__result)).second;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__iterator/ranges_iterator_traits.h b/libcxx/include/__iterator/ranges_iterator_traits.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__iterator/ranges_iterator_traits.h
@@ -0,0 +1,42 @@
+// -*- 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___ITERATOR_RANGES_ITERATOR_TRAITS_H
+#define _LIBCPP___ITERATOR_RANGES_ITERATOR_TRAITS_H
+
+#include <__config>
+#include <__fwd/pair.h>
+#include <__ranges/concepts.h>
+#include <__type_traits/add_const.h>
+#include <__type_traits/remove_const.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range>
+using __range_key_type = remove_const_t<typename ranges::range_value_t<_Range>::first_type>;
+
+template <ranges::input_range _Range>
+using __range_mapped_type = typename ranges::range_value_t<_Range>::second_type;
+
+template <ranges::input_range _Range>
+using __range_to_alloc_type =
+    pair<add_const_t<typename ranges::range_value_t<_Range>::first_type>,
+         typename ranges::range_value_t<_Range>::second_type>;
+
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_RANGES_ITERATOR_TRAITS_H
diff --git a/libcxx/include/__ranges/container_compatible_range.h b/libcxx/include/__ranges/container_compatible_range.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/container_compatible_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_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,246 @@
+// -*- 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 <__algorithm/ranges_copy.h>
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/derived_from.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#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/from_range.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/size.h>
+#include <__ranges/transform_view.h>
+#include <__type_traits/add_pointer.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_volatile.h>
+#include <__type_traits/type_identity.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+template <class _Container>
+constexpr bool __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)); } ||
+      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 std::back_inserter(__c);
+  } else {
+    return std::inserter(__c, __c.end());
+  }
+}
+
+template <class _Container, class _Range>
+concept __try_non_recursive_conversion =
+    !input_range<_Container> || convertible_to<range_reference_t<_Range>, range_value_t<_Container>>;
+
+template <class _Container, class _Range, class... _Args>
+concept __constructible_from_iter_pair = common_range<_Range> && requires {
+  typename iterator_traits<iterator_t<_Range>>::iterator_category;
+} && derived_from<typename iterator_traits<iterator_t<_Range>>::iterator_category, input_iterator_tag> &&
+    constructible_from<_Container, iterator_t<_Range>, sentinel_t<_Range>, _Args...>;
+
+template <class>
+concept __always_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) {
+  // Mandates: C is a cv-unqualified class type.
+  static_assert(!is_const_v<_Container>, "The target container cannot be const-qualified, please remove the const");
+  static_assert(!is_volatile_v<_Container>,
+                "The target container cannot be volatile-qualified, please remove the volatile");
+
+  // 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 (__try_non_recursive_conversion<_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 (__constructible_from_iter_pair<_Container, _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(__always_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 ranges::to<_Container>(
+        __range | views::transform([](auto&& __elem) {
+          return ranges::to<range_value_t<_Container>>(std::forward<decltype(__elem)>(__elem));
+        }),
+        std::forward<_Args>(__args)...);
+
+  } else {
+    static_assert(__always_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 (requires { _Container(std::declval<_Range>(), std::declval<_Args>()...); }) {
+      using _Result = decltype( //
+          _Container(std::declval<_Range>(), std::declval<_Args>()...));
+      return type_identity<_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 type_identity<_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 type_identity<_Result>{};
+
+    } else {
+      static_assert(__always_false<_Range>,
+                    "ranges::to: unable to deduce the container type from the template template argument.");
+    }
+  }
+
+  using type = typename decltype(__deduce_func())::type;
+};
+
+// `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 ranges::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) {
+  // Mandates: C is a cv-unqualified class type.
+  static_assert(!is_const_v<_Container>, "The target container cannot be const-qualified, please remove the const");
+  static_assert(!is_volatile_v<_Container>,
+                "The target container cannot be volatile-qualified, please remove the volatile");
+
+  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<_DeducedExpr>(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+  }
+  { return ranges::to<_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/__split_buffer b/libcxx/include/__split_buffer
--- a/libcxx/include/__split_buffer
+++ b/libcxx/include/__split_buffer
@@ -170,6 +170,14 @@
       __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value>
       __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
 
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  void __construct_at_end_with_sentinel(_Iterator __first, _Sentinel __last);
+
+  template <class _Iterator>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  void __construct_at_end_with_size(_Iterator __first, size_type __n);
+
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __destruct_at_begin(pointer __new_begin) {
     __destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());
   }
@@ -279,6 +287,13 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 __enable_if_t<__is_exactly_cpp17_input_iterator<_InputIter>::value>
 __split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last)
 {
+  __construct_at_end_with_sentinel(__first, __last);
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20
+void __split_buffer<_Tp, _Allocator>::__construct_at_end_with_sentinel(_Iterator __first, _Sentinel __last) {
     __alloc_rr& __a = this->__alloc();
     for (; __first != __last; ++__first)
     {
@@ -296,13 +311,19 @@
         ++this->__end_;
     }
 }
-
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value>
 __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
 {
-    _ConstructTransaction __tx(&this->__end_, _VSTD::distance(__first, __last));
+  __construct_at_end_with_size(__first, std::distance(__first, __last));
+}
+
+template <class _Tp, class _Allocator>
+template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20
+void __split_buffer<_Tp, _Allocator>::__construct_at_end_with_size(_ForwardIterator __first, size_type __n) {
+    _ConstructTransaction __tx(&this->__end_, __n);
     for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void) ++__first) {
         __alloc_traits::construct(this->__alloc(),
             _VSTD::__to_address(__tx.__pos_), *__first);
diff --git a/libcxx/include/deque b/libcxx/include/deque
--- a/libcxx/include/deque
+++ b/libcxx/include/deque
@@ -47,6 +47,8 @@
         deque(InputIterator f, InputIterator l);
     template <class InputIterator>
         deque(InputIterator f, InputIterator l, const allocator_type& a);
+    template<container-compatible-range<T> R>
+        deque(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
     deque(const deque& c);
     deque(deque&& c)
         noexcept(is_nothrow_move_constructible<allocator_type>::value);
@@ -64,6 +66,8 @@
 
     template <class InputIterator>
         void assign(InputIterator f, InputIterator l);
+    template<container-compatible-range<T> R>
+      void assign_range(R&& rg); // C++23
     void assign(size_type n, const value_type& v);
     void assign(initializer_list<value_type> il);
 
@@ -107,8 +111,12 @@
     // modifiers:
     void push_front(const value_type& v);
     void push_front(value_type&& v);
+    template<container-compatible-range<T> R>
+      void prepend_range(R&& rg); // C++23
     void push_back(const value_type& v);
     void push_back(value_type&& v);
+    template<container-compatible-range<T> R>
+      void append_range(R&& rg); // C++23
     template <class... Args> reference emplace_front(Args&&... args);  // reference in C++17
     template <class... Args> reference emplace_back(Args&&... args);   // reference in C++17
     template <class... Args> iterator emplace(const_iterator p, Args&&... args);
@@ -117,6 +125,8 @@
     iterator insert(const_iterator p, size_type n, const value_type& v);
     template <class InputIterator>
         iterator insert(const_iterator p, InputIterator f, InputIterator l);
+    template<container-compatible-range<T> R>
+      iterator insert_range(const_iterator position, R&& rg); // C++23
     iterator insert(const_iterator p, initializer_list<value_type> il);
     void pop_front();
     void pop_back();
@@ -131,6 +141,10 @@
    deque(InputIterator, InputIterator, Allocator = Allocator())
    -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+  deque(from_range_t, R&&, Allocator = Allocator())
+    -> deque<ranges::range_value_t<R>, Allocator>; // C++23
+
 template <class T, class Allocator>
     bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
 template <class T, class Allocator>
@@ -164,9 +178,11 @@
 */
 
 #include <__algorithm/copy.h>
+#include <__algorithm/copy_n.h>
 #include <__algorithm/copy_backward.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
+#include <__algorithm/iterator_operations.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/min.h>
@@ -176,6 +192,7 @@
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__format/enable_insertable.h>
+#include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
@@ -187,6 +204,11 @@
 #include <__memory/temp_value.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
+#include <__ranges/size.h>
 #include <__split_buffer>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_convertible.h>
@@ -590,6 +612,23 @@
     template <class _InputIter>
     _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
               typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI deque(from_range_t, _Range&& __range,
+      const allocator_type& __a = allocator_type())
+    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      __append_with_size(ranges::begin(__range), ranges::distance(__range));
+
+    } else {
+      for (auto&& __e : __range) {
+        emplace_back(std::forward<decltype(__e)>(__e));
+      }
+    }
+  }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI deque(const deque& __c);
     _LIBCPP_HIDE_FROM_ABI deque(const deque& __c, const __type_identity_t<allocator_type>& __a);
 
@@ -622,6 +661,21 @@
     template <class _RAIter>
     _LIBCPP_HIDE_FROM_ABI void assign(_RAIter __f, _RAIter __l,
                     typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void assign_range(_Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        __assign_with_size(ranges::begin(__range), __n);
+
+      } else {
+        __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
 
     _LIBCPP_HIDE_FROM_ABI
@@ -731,6 +785,21 @@
 
     _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __v);
     _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __v);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void prepend_range(_Range&& __range) {
+      insert_range(begin(), std::forward<_Range>(__range));
+    }
+
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void append_range(_Range&& __range) {
+      insert_range(end(), std::forward<_Range>(__range));
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v);
 
     _LIBCPP_HIDE_FROM_ABI
@@ -749,6 +818,24 @@
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _BiIter __f, _BiIter __l,
                          typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type* = 0);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator insert_range(const_iterator __position, _Range&& __range) {
+      if constexpr (ranges::bidirectional_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_bidirectional(__position, ranges::begin(__range), ranges::end(__range), __n);
+
+      } else if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_with_size(__position, ranges::begin(__range), __n);
+
+      } else {
+        return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI void pop_front();
     _LIBCPP_HIDE_FROM_ABI void pop_back();
     _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
@@ -881,12 +968,41 @@
       return false;
     }
 
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_sentinel(_Iterator __f, _Sentinel __l);
+
+    template <class _Iterator>
+    _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_size(_Iterator __f, difference_type __n);
+
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l);
+
+    template <class _Iterator>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_with_size(const_iterator __p, _Iterator __f, size_type __n);
+
+    template <class _BiIter, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel __sent, size_type __n);
+    template <class _BiIter>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n);
+
     template <class _InpIter>
     _LIBCPP_HIDE_FROM_ABI void __append(_InpIter __f, _InpIter __l,
                  typename enable_if<__is_exactly_cpp17_input_iterator<_InpIter>::value>::type* = 0);
     template <class _ForIter>
     _LIBCPP_HIDE_FROM_ABI void __append(_ForIter __f, _ForIter __l,
                       typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type* = 0);
+
+    template <class _InputIterator>
+    _LIBCPP_HIDE_FROM_ABI void __append_with_size(_InputIterator __from, size_type __n);
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI void __append_with_sentinel(_InputIterator __f, _Sentinel __l);
+
     _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
     _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const value_type& __v);
     _LIBCPP_HIDE_FROM_ABI void __erase_to_end(const_iterator __f);
@@ -951,6 +1067,15 @@
   -> deque<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Alloc = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Alloc>::value>
+          >
+deque(from_range_t, _Range&&, _Alloc = _Alloc())
+  -> deque<ranges::range_value_t<_Range>, _Alloc>;
+#endif
+
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(size_type __n)
     : __start_(0), __size_(0, __default_init_tag())
@@ -1115,12 +1240,19 @@
                                typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
                                                  !__is_cpp17_random_access_iterator<_InputIter>::value>::type*)
 {
+  __assign_with_sentinel(__f, __l);
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __f, _Sentinel __l) {
     iterator __i = begin();
     iterator __e = end();
     for (; __f != __l && __i != __e; ++__f, (void) ++__i)
         *__i = *__f;
     if (__f != __l)
-        __append(__f, __l);
+        __append_with_sentinel(std::move(__f), std::move(__l));
     else
         __erase_to_end(__i);
 }
@@ -1131,14 +1263,20 @@
 deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
                                typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*)
 {
-    if (static_cast<size_type>(__l - __f) > size())
+  __assign_with_size(__f, __l - __f);
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__assign_with_size(_Iterator __f, difference_type __n) {
+    if (static_cast<size_type>(__n) > size())
     {
-        _RAIter __m = __f + size();
-        _VSTD::copy(__f, __m, begin());
-        __append(__m, __l);
+        auto __rest = std::__copy_n<_ClassicAlgPolicy>(__f, size(), begin()).first;
+        __append_with_size(__rest, __n - size());
     }
     else
-        __erase_to_end(_VSTD::copy(__f, __l, begin()));
+        __erase_to_end(std::__copy_n<_ClassicAlgPolicy>(__f, __n, begin()).second);
 }
 
 template <class _Tp, class _Allocator>
@@ -1616,8 +1754,16 @@
 deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l,
                                typename enable_if<__is_exactly_cpp17_input_iterator<_InputIter>::value>::type*)
 {
+  return __insert_with_sentinel(__p, __f, __l);
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+typename deque<_Tp, _Allocator>::iterator
+deque<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l) {
     __split_buffer<value_type, allocator_type&> __buf(__alloc());
-    __buf.__construct_at_end(__f, __l);
+    __buf.__construct_at_end_with_sentinel(std::move(__f), std::move(__l));
     typedef typename __split_buffer<value_type, allocator_type&>::iterator __bi;
     return insert(__p, move_iterator<__bi>(__buf.begin()), move_iterator<__bi>(__buf.end()));
 }
@@ -1628,9 +1774,16 @@
 deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
                                typename enable_if<__is_exactly_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
 {
-    size_type __n = _VSTD::distance(__f, __l);
+  return __insert_with_size(__p, __f, std::distance(__f, __l));
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator>
+_LIBCPP_HIDE_FROM_ABI
+typename deque<_Tp, _Allocator>::iterator
+deque<_Tp, _Allocator>::__insert_with_size(const_iterator __p, _Iterator __f, size_type __n) {
     __split_buffer<value_type, allocator_type&> __buf(__n, 0, __alloc());
-    __buf.__construct_at_end(__f, __l);
+    __buf.__construct_at_end_with_size(__f, __n);
     typedef typename __split_buffer<value_type, allocator_type&>::iterator __fwd;
     return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end()));
 }
@@ -1641,7 +1794,22 @@
 deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
                                typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type*)
 {
-    size_type __n = _VSTD::distance(__f, __l);
+  return __insert_bidirectional(__p, __f, __l, std::distance(__f, __l));
+}
+
+template <class _Tp, class _Allocator>
+template <class _BiIter, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+typename deque<_Tp, _Allocator>::iterator
+deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel, size_type __n) {
+  return __insert_bidirectional(__p, __f, std::next(__f, __n), __n);
+}
+
+template <class _Tp, class _Allocator>
+template <class _BiIter>
+_LIBCPP_HIDE_FROM_ABI
+typename deque<_Tp, _Allocator>::iterator
+deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n) {
     size_type __pos = __p - begin();
     size_type __to_end = size() - __pos;
     allocator_type& __a = __alloc();
@@ -1710,6 +1878,13 @@
 deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,
                                  typename enable_if<__is_exactly_cpp17_input_iterator<_InpIter>::value>::type*)
 {
+  __append_with_sentinel(__f, __l);
+}
+
+template <class _Tp, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__append_with_sentinel(_InputIterator __f, _Sentinel __l) {
     for (; __f != __l; ++__f)
 #ifdef _LIBCPP_CXX03_LANG
         push_back(*__f);
@@ -1724,11 +1899,18 @@
 deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
                                  typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type*)
 {
-    size_type __n = _VSTD::distance(__f, __l);
+    __append_with_size(__f, std::distance(__f, __l));
+}
+
+template <class _Tp, class _Allocator>
+template <class _InputIterator>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__append_with_size(_InputIterator __f, size_type __n) {
     allocator_type& __a = __alloc();
     size_type __back_capacity = __back_spare();
     if (__n > __back_capacity)
         __add_back_capacity(__n - __back_capacity);
+
     // __n <= __back_capacity
     for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
       _ConstructTransaction __tx(this, __br);
diff --git a/libcxx/include/forward_list b/libcxx/include/forward_list
--- a/libcxx/include/forward_list
+++ b/libcxx/include/forward_list
@@ -44,6 +44,8 @@
         forward_list(InputIterator first, InputIterator last);
     template <class InputIterator>
         forward_list(InputIterator first, InputIterator last, const allocator_type& a);
+    template<container-compatible-range<T> R>
+        forward_list(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
     forward_list(const forward_list& x);
     forward_list(const forward_list& x, const allocator_type& a);
     forward_list(forward_list&& x)
@@ -63,6 +65,8 @@
 
     template <class InputIterator>
         void assign(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      void assign_range(R&& rg); // C++23
     void assign(size_type n, const value_type& v);
     void assign(initializer_list<value_type> il);
 
@@ -89,6 +93,8 @@
     template <class... Args> reference emplace_front(Args&&... args);  // reference in C++17
     void push_front(const value_type& v);
     void push_front(value_type&& v);
+    template<container-compatible-range<T> R>
+      void prepend_range(R&& rg); // C++23
 
     void pop_front();
 
@@ -100,6 +106,8 @@
     template <class InputIterator>
         iterator insert_after(const_iterator p,
                               InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      iterator insert_range_after(const_iterator position, R&& rg); // C++23
     iterator insert_after(const_iterator p, initializer_list<value_type> il);
 
     iterator erase_after(const_iterator p);
@@ -140,6 +148,10 @@
     forward_list(InputIterator, InputIterator, Allocator = Allocator())
     -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>;  // C++17
 
+template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+  forward_list(from_range_t, R&&, Allocator = Allocator())
+      -> forward_list<ranges::range_value_t<R>, Allocator>; // C++23
+
 template <class T, class Allocator>
     bool operator==(const forward_list<T, Allocator>& x,
                     const forward_list<T, Allocator>& y);
@@ -202,6 +214,10 @@
 #include <__memory/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_const.h>
@@ -714,6 +730,15 @@
     _LIBCPP_HIDE_FROM_ABI forward_list(_InputIterator __f, _InputIterator __l,
                      const allocator_type& __a,
                      __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>* = nullptr);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI forward_list(from_range_t, _Range&& __range,
+        const allocator_type& __a = allocator_type()) : base(__a) {
+      prepend_range(std::forward<_Range>(__range));
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI forward_list(const forward_list& __x);
     _LIBCPP_HIDE_FROM_ABI forward_list(const forward_list& __x, const __type_identity_t<allocator_type>& __a);
 
@@ -747,6 +772,15 @@
     template <class _InputIterator>
     __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value, void>
     _LIBCPP_HIDE_FROM_ABI assign(_InputIterator __f, _InputIterator __l);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void assign_range(_Range&& __range) {
+      __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
 
     _LIBCPP_INLINE_VISIBILITY
@@ -810,6 +844,14 @@
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void prepend_range(_Range&& __range) {
+      insert_range_after(cbefore_begin(), std::forward<_Range>(__range));
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI void pop_front();
 
 #ifndef _LIBCPP_CXX03_LANG
@@ -827,6 +869,18 @@
     __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value, iterator>
         insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator insert_range_after(const_iterator __position, _Range&& __range) {
+      return __insert_after_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
+    }
+#endif
+
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_after_with_sentinel(const_iterator __p, _InputIterator __f, _Sentinel __l);
+
     _LIBCPP_HIDE_FROM_ABI iterator erase_after(const_iterator __p);
     _LIBCPP_HIDE_FROM_ABI iterator erase_after(const_iterator __f, const_iterator __l);
 
@@ -888,6 +942,10 @@
     _LIBCPP_HIDE_FROM_ABI void __move_assign(forward_list& __x, false_type);
 #endif // _LIBCPP_CXX03_LANG
 
+    template <class _Iter, class _Sent>
+    _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_sentinel(_Iter __f, _Sent __l);
+
     template <class _Compare>
     static _LIBCPP_HIDE_FROM_ABI
         __node_pointer
@@ -919,6 +977,15 @@
   -> forward_list<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Alloc = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Alloc>::value>
+          >
+forward_list(from_range_t, _Range&&, _Alloc = _Alloc())
+  -> forward_list<ranges::range_value_t<_Range>, _Alloc>;
+#endif
+
 template <class _Tp, class _Alloc>
 inline
 forward_list<_Tp, _Alloc>::forward_list(const allocator_type& __a)
@@ -1099,13 +1166,20 @@
 __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value, void>
 forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
 {
+  __assign_with_sentinel(__f, __l);
+}
+
+template <class _Tp, class _Alloc>
+template <class _Iter, class _Sent>
+_LIBCPP_HIDE_FROM_ABI
+void forward_list<_Tp, _Alloc>::__assign_with_sentinel(_Iter __f, _Sent __l) {
     iterator __i = before_begin();
     iterator __j = _VSTD::next(__i);
     iterator __e = end();
     for (; __j != __e && __f != __l; ++__i, (void) ++__j, ++__f)
         *__j = *__f;
     if (__j == __e)
-        insert_after(__i, __f, __l);
+        __insert_after_with_sentinel(__i, std::move(__f), std::move(__l));
     else
         erase_after(__i, __e);
 }
@@ -1292,7 +1366,16 @@
 forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
                                         _InputIterator __f, _InputIterator __l)
 {
+  return __insert_after_with_sentinel(__p, std::move(__f), std::move(__l));
+}
+
+template <class _Tp, class _Alloc>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+typename forward_list<_Tp, _Alloc>::iterator
+forward_list<_Tp, _Alloc>::__insert_after_with_sentinel(const_iterator __p, _InputIterator __f, _Sentinel __l) {
     __begin_node_pointer __r = __p.__get_begin();
+
     if (__f != __l)
     {
         __node_allocator& __a = base::__alloc();
@@ -1301,6 +1384,7 @@
         __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
         __node_pointer __first = __h.release();
         __node_pointer __last = __first;
+
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         try
         {
@@ -1325,10 +1409,12 @@
             throw;
         }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
+
         __last->__next_ = __r->__next_;
         __r->__next_ = __first;
         __r = static_cast<__begin_node_pointer>(__last);
     }
+
     return iterator(__r);
 }
 
diff --git a/libcxx/include/list b/libcxx/include/list
--- a/libcxx/include/list
+++ b/libcxx/include/list
@@ -46,6 +46,8 @@
         list(Iter first, Iter last);
     template <class Iter>
         list(Iter first, Iter last, const allocator_type& a);
+    template<container-compatible-range<T> R>
+      list(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
     list(const list& x);
     list(const list&, const allocator_type& a);
     list(list&& x)
@@ -64,6 +66,8 @@
     list& operator=(initializer_list<value_type>);
     template <class Iter>
         void assign(Iter first, Iter last);
+    template<container-compatible-range<T> R>
+      void assign_range(R&& rg); // C++23
     void assign(size_type n, const value_type& t);
     void assign(initializer_list<value_type>);
 
@@ -99,8 +103,12 @@
     void pop_back();
     void push_front(const value_type& x);
     void push_front(value_type&& x);
+    template<container-compatible-range<T> R>
+      void prepend_range(R&& rg); // C++23
     void push_back(const value_type& x);
     void push_back(value_type&& x);
+    template<container-compatible-range<T> R>
+      void append_range(R&& rg); // C++23
     template <class... Args>
         iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const value_type& x);
@@ -108,6 +116,8 @@
     iterator insert(const_iterator position, size_type n, const value_type& x);
     template <class Iter>
         iterator insert(const_iterator position, Iter first, Iter last);
+    template<container-compatible-range<T> R>
+      iterator insert_range(const_iterator position, R&& rg); // C++23
     iterator insert(const_iterator position, initializer_list<value_type> il);
 
     iterator erase(const_iterator position);
@@ -152,6 +162,10 @@
     list(InputIterator, InputIterator, Allocator = Allocator())
     -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;  // C++17
 
+template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+  list(from_range_t, R&&, Allocator = Allocator())
+    -> list<ranges::range_value_t<R>, Allocator>; // C++23
+
 template <class T, class Alloc>
     bool operator==(const list<T,Alloc>& x, const list<T,Alloc>& y);
 template <class T, class Alloc>
@@ -207,6 +221,9 @@
 #include <__memory/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
@@ -886,6 +903,17 @@
     _LIBCPP_HIDE_FROM_ABI list(_InpIter __f, _InpIter __l, const allocator_type& __a,
              __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = 0);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI list(from_range_t, _Range&& __range,
+        const allocator_type& __a = allocator_type()) : base(__a) {
+      std::__debug_db_insert_c(this);
+      for (auto&& __e : __range) {
+        __emplace_back(std::forward<decltype(__e)>(__e));
+      }
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI list(const list& __c);
     _LIBCPP_HIDE_FROM_ABI list(const list& __c, const __type_identity_t<allocator_type>& __a);
     _LIBCPP_INLINE_VISIBILITY
@@ -917,6 +945,15 @@
     template <class _InpIter>
     _LIBCPP_HIDE_FROM_ABI void assign(_InpIter __f, _InpIter __l,
                     __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = 0);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void assign_range(_Range&& __range) {
+      __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __x);
 
     _LIBCPP_INLINE_VISIBILITY
@@ -995,6 +1032,20 @@
     _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __x);
     _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __x);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void prepend_range(_Range&& __range) {
+      insert_range(begin(), std::forward<_Range>(__range));
+    }
+
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void append_range(_Range&& __range) {
+      insert_range(end(), std::forward<_Range>(__range));
+    }
+#endif
+
     template <class... _Args>
 #if _LIBCPP_STD_VER >= 17
     _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
@@ -1035,6 +1086,14 @@
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,
                         __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>* = 0);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator insert_range(const_iterator __position, _Range&& __range) {
+      return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
+    }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     void swap(list& __c)
 #if _LIBCPP_STD_VER >= 14
@@ -1120,6 +1179,12 @@
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 private:
+    template <class _Iterator, class _Sentinel>
+    void __assign_with_sentinel(_Iterator __f, _Sentinel __l);
+
+    template <class _Iterator, class _Sentinel>
+    iterator __insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l);
+
     _LIBCPP_INLINE_VISIBILITY
     static void __link_nodes  (__link_pointer __p, __link_pointer __f, __link_pointer __l);
     _LIBCPP_INLINE_VISIBILITY
@@ -1154,6 +1219,15 @@
   -> list<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Alloc = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Alloc>::value>
+          >
+list(from_range_t, _Range&&, _Alloc = _Alloc())
+  -> list<ranges::range_value_t<_Range>, _Alloc>;
+#endif
+
 // Link in nodes [__f, __l] just prior to __p
 template <class _Tp, class _Alloc>
 inline
@@ -1370,12 +1444,18 @@
 list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l,
                           __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>*)
 {
+  __assign_with_sentinel(__f, __l);
+}
+
+template <class _Tp, class _Alloc>
+template <class _Iterator, class _Sentinel>
+void list<_Tp, _Alloc>::__assign_with_sentinel(_Iterator __f, _Sentinel __l) {
     iterator __i = begin();
     iterator __e = end();
     for (; __f != __l && __i != __e; ++__f, (void) ++__i)
         *__i = *__f;
     if (__i == __e)
-        insert(__e, __f, __l);
+        __insert_with_sentinel(__e, std::move(__f), std::move(__l));
     else
         erase(__i, __e);
     std::__debug_db_invalidate_all(this);
@@ -1475,8 +1555,16 @@
 list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
                           __enable_if_t<__is_cpp17_input_iterator<_InpIter>::value>*)
 {
+    return __insert_with_sentinel(__p, __f, __l);
+}
+
+template <class _Tp, class _Alloc>
+template <class _Iterator, class _Sentinel>
+typename list<_Tp, _Alloc>::iterator
+list<_Tp, _Alloc>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l) {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "list::insert(iterator, range) called with an iterator not referring to this list");
+                         "list::insert called with an iterator not referring to this list");
+
     iterator __r(__p.__ptr_, this);
     if (__f != __l)
     {
diff --git a/libcxx/include/map b/libcxx/include/map
--- a/libcxx/include/map
+++ b/libcxx/include/map
@@ -70,6 +70,8 @@
     template <class InputIterator>
         map(InputIterator first, InputIterator last,
             const key_compare& comp, const allocator_type& a);
+    template<container-compatible-range<value_type> R>
+      map(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
     map(const map& m);
     map(map&& m)
         noexcept(
@@ -83,6 +85,9 @@
     template <class InputIterator>
         map(InputIterator first, InputIterator last, const allocator_type& a)
             : map(first, last, Compare(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      map(from_range_t, R&& rg, const Allocator& a))
+        : map(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
     map(initializer_list<value_type> il, const allocator_type& a)
         : map(il, Compare(), a) {}  // C++14
    ~map();
@@ -138,6 +143,8 @@
         iterator insert(const_iterator position, P&& p);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type> il);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -229,6 +236,11 @@
 map(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
   -> map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Compare, Allocator>; // C++17
 
+template<ranges::input_range R, class Compare = less<range-key-type<R>,
+         class Allocator = allocator<range-to-alloc-type<R>>>
+  map(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+    -> map<range-key-type<R>, range-mapped-type<R>, Compare, Allocator>; // C++23
+
 template<class Key, class T, class Compare = less<Key>,
     class Allocator = allocator<pair<const Key, T>>>
 map(initializer_list<pair<const Key, T>>, Compare = Compare(), Allocator = Allocator())
@@ -239,6 +251,10 @@
   -> map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, less<iter_key_t<InputIterator>>,
     Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  map(from_range_t, R&&, Allocator)
+    -> map<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>, Allocator>; // C++23
+
 template<class Key, class T, class Allocator>
 map(initializer_list<pair<const Key, T>>, Allocator) -> map<Key, T, less<Key>, Allocator>; // C++17
 
@@ -338,6 +354,9 @@
     template <class InputIterator>
         multimap(InputIterator first, InputIterator last, const key_compare& comp,
                  const allocator_type& a);
+    template<container-compatible-range<value_type> R>
+      multimap(from_range_t, R&& rg,
+               const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
     multimap(const multimap& m);
     multimap(multimap&& m)
         noexcept(
@@ -352,6 +371,9 @@
     template <class InputIterator>
         multimap(InputIterator first, InputIterator last, const allocator_type& a)
             : multimap(first, last, Compare(), a) {} // C++14
+    template<container-compatible-range<value_type> R>
+      multimap(from_range_t, R&& rg, const Allocator& a))
+        : multimap(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
     multimap(initializer_list<value_type> il, const allocator_type& a)
         : multimap(il, Compare(), a) {} // C++14
     ~multimap();
@@ -400,6 +422,8 @@
         iterator insert(const_iterator position, P&& p);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type> il);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -474,6 +498,11 @@
 multimap(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
   -> multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Compare, Allocator>; // C++17
 
+template<ranges::input_range R, class Compare = less<range-key-type<R>>,
+          class Allocator = allocator<range-to-alloc-type<R>>>
+  multimap(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+    -> multimap<range-key-type<R>, range-mapped-type<R>, Compare, Allocator>; // C++23
+
 template<class Key, class T, class Compare = less<Key>,
     class Allocator = allocator<pair<const Key, T>>>
 multimap(initializer_list<pair<const Key, T>>, Compare = Compare(), Allocator = Allocator())
@@ -484,6 +513,10 @@
   -> multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
     less<iter_key_t<InputIterator>>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  multimap(from_range_t, R&&, Allocator)
+    -> multimap<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>, Allocator>; // C++23
+
 template<class Key, class T, class Allocator>
 multimap(initializer_list<pair<const Key, T>>, Allocator)
   -> multimap<Key, T, less<Key>, Allocator>; // C++17
@@ -548,11 +581,15 @@
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/ranges_iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__tree>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
@@ -1078,6 +1115,16 @@
             insert(__f, __l);
         }
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    map(from_range_t, _Range&& __range, const key_compare& __comp = key_compare(),
+        const allocator_type& __a = allocator_type())
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {
+      insert_range(std::forward<_Range>(__range));
+    }
+#endif
+
 #if _LIBCPP_STD_VER >= 14
     template <class _InputIterator>
     _LIBCPP_INLINE_VISIBILITY
@@ -1085,6 +1132,13 @@
         : map(__f, __l, key_compare(), __a) {}
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    map(from_range_t, _Range&& __range, const allocator_type& __a)
+      : map(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     map(const map& __m)
         : __tree_(__m.__tree_)
@@ -1284,6 +1338,17 @@
                 insert(__e.__i_, *__f);
         }
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void insert_range(_Range&& __range) {
+      const_iterator __end = cend();
+      for (auto&& __element : __range) {
+        insert(__end.__i_, std::forward<decltype(__element)>(__element));
+      }
+    }
+#endif
+
 #if _LIBCPP_STD_VER >= 17
 
     template <class... _Args>
@@ -1569,6 +1634,15 @@
 map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
   -> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Compare = less<__range_key_type<_Range>>,
+          class _Allocator = allocator<__range_to_alloc_type<_Range>>,
+          class = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+  -> map<__range_key_type<_Range>, __range_mapped_type<_Range>, _Compare, _Allocator>;
+#endif
+
 template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,
          class _Allocator = allocator<pair<const _Key, _Tp>>,
          class = enable_if_t<!__is_allocator<_Compare>::value, void>,
@@ -1583,6 +1657,13 @@
   -> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
          less<__iter_key_type<_InputIterator>>, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+map(from_range_t, _Range&&, _Allocator)
+  -> map<__range_key_type<_Range>, __range_mapped_type<_Range>, less<__range_key_type<_Range>>, _Allocator>;
+#endif
+
 template<class _Key, class _Tp, class _Allocator,
          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
 map(initializer_list<pair<_Key, _Tp>>, _Allocator)
@@ -1877,6 +1958,16 @@
             insert(__f, __l);
         }
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    multimap(from_range_t, _Range&& __range, const key_compare& __comp = key_compare(),
+        const allocator_type& __a = allocator_type())
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {
+      insert_range(std::forward<_Range>(__range));
+    }
+#endif
+
 #if _LIBCPP_STD_VER >= 14
     template <class _InputIterator>
     _LIBCPP_INLINE_VISIBILITY
@@ -1884,6 +1975,13 @@
         : multimap(__f, __l, key_compare(), __a) {}
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    multimap(from_range_t, _Range&& __range, const allocator_type& __a)
+      : multimap(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     multimap(const multimap& __m)
         : __tree_(__m.__tree_.value_comp(),
@@ -2074,6 +2172,17 @@
                 __tree_.__insert_multi(__e.__i_, *__f);
         }
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void insert_range(_Range&& __range) {
+      const_iterator __end = cend();
+      for (auto&& __element : __range) {
+        __tree_.__insert_multi(__end.__i_, std::forward<decltype(__element)>(__element));
+      }
+    }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
     _LIBCPP_INLINE_VISIBILITY
@@ -2258,6 +2367,15 @@
 multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
   -> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Compare = less<__range_key_type<_Range>>,
+          class _Allocator = allocator<__range_to_alloc_type<_Range>>,
+          class = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multimap(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+  -> multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, _Compare, _Allocator>;
+#endif
+
 template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,
          class _Allocator = allocator<pair<const _Key, _Tp>>,
          class = enable_if_t<!__is_allocator<_Compare>::value, void>,
@@ -2272,6 +2390,13 @@
   -> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
          less<__iter_key_type<_InputIterator>>, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multimap(from_range_t, _Range&&, _Allocator)
+  -> multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, less<__range_key_type<_Range>>, _Allocator>;
+#endif
+
 template<class _Key, class _Tp, class _Allocator,
          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
 multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
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
@@ -1041,62 +1041,63 @@
     export *
 
     module __iterator {
-      module access                { private header "__iterator/access.h" }
-      module advance               { private header "__iterator/advance.h" }
-      module back_insert_iterator  { private header "__iterator/back_insert_iterator.h" }
-      module bounded_iter          { private header "__iterator/bounded_iter.h" }
-      module common_iterator       { private header "__iterator/common_iterator.h" }
-      module concepts {
+      module access                 { private header "__iterator/access.h" }
+      module advance                { private header "__iterator/advance.h" }
+      module back_insert_iterator   { private header "__iterator/back_insert_iterator.h" }
+      module bounded_iter           { private header "__iterator/bounded_iter.h" }
+      module common_iterator        { private header "__iterator/common_iterator.h" }
+      module concepts               {
         private header "__iterator/concepts.h"
         export concepts.equality_comparable
         export type_traits.common_reference
       }
-      module counted_iterator      { private header "__iterator/counted_iterator.h" }
-      module data                  { private header "__iterator/data.h" }
-      module default_sentinel      { private header "__iterator/default_sentinel.h" }
-      module distance              { private header "__iterator/distance.h" }
-      module empty                 { private header "__iterator/empty.h" }
-      module erase_if_container    { private header "__iterator/erase_if_container.h" }
-      module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
-      module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
-      module indirectly_comparable { private header "__iterator/indirectly_comparable.h" }
-      module insert_iterator       { private header "__iterator/insert_iterator.h" }
-      module istream_iterator      { private header "__iterator/istream_iterator.h" }
-      module istreambuf_iterator   { private header "__iterator/istreambuf_iterator.h" }
-      module iter_move             { private header "__iterator/iter_move.h" }
-      module iter_swap             { private header "__iterator/iter_swap.h" }
-      module iterator              { private header "__iterator/iterator.h" }
-      module iterator_traits       { private header "__iterator/iterator_traits.h" }
-      module iterator_with_data    { private header "__iterator/iterator_with_data.h" }
+      module counted_iterator       { private header "__iterator/counted_iterator.h" }
+      module data                   { private header "__iterator/data.h" }
+      module default_sentinel       { private header "__iterator/default_sentinel.h" }
+      module distance               { private header "__iterator/distance.h" }
+      module empty                  { private header "__iterator/empty.h" }
+      module erase_if_container     { private header "__iterator/erase_if_container.h" }
+      module front_insert_iterator  { private header "__iterator/front_insert_iterator.h" }
+      module incrementable_traits   { private header "__iterator/incrementable_traits.h" }
+      module indirectly_comparable  { private header "__iterator/indirectly_comparable.h" }
+      module insert_iterator        { private header "__iterator/insert_iterator.h" }
+      module istream_iterator       { private header "__iterator/istream_iterator.h" }
+      module istreambuf_iterator    { private header "__iterator/istreambuf_iterator.h" }
+      module iter_move              { private header "__iterator/iter_move.h" }
+      module iter_swap              { private header "__iterator/iter_swap.h" }
+      module iterator               { private header "__iterator/iterator.h" }
+      module iterator_traits        { private header "__iterator/iterator_traits.h" }
+      module iterator_with_data     { private header "__iterator/iterator_with_data.h" }
       module mergeable {
         private header "__iterator/mergeable.h"
         export functional.__functional.ranges_operations
       }
-      module move_iterator         { private header "__iterator/move_iterator.h" }
-      module move_sentinel         { private header "__iterator/move_sentinel.h" }
-      module next                  { private header "__iterator/next.h" }
-      module ostream_iterator      { private header "__iterator/ostream_iterator.h" }
-      module ostreambuf_iterator   {
+      module move_iterator          { private header "__iterator/move_iterator.h" }
+      module move_sentinel          { private header "__iterator/move_sentinel.h" }
+      module next                   { private header "__iterator/next.h" }
+      module ostream_iterator       { private header "__iterator/ostream_iterator.h" }
+      module ostreambuf_iterator    {
         private header "__iterator/ostreambuf_iterator.h"
         export iosfwd
       }
-      module permutable            { private header "__iterator/permutable.h" }
-      module prev                  { private header "__iterator/prev.h" }
-      module projected             { private header "__iterator/projected.h" }
-      module readable_traits       {
+      module permutable             { private header "__iterator/permutable.h" }
+      module prev                   { private header "__iterator/prev.h" }
+      module projected              { private header "__iterator/projected.h" }
+      module ranges_iterator_traits { private header "__iterator/ranges_iterator_traits.h" }
+      module readable_traits        {
         private header "__iterator/readable_traits.h"
         export __iterator.iterator_traits
       }
-      module reverse_access        { private header "__iterator/reverse_access.h" }
-      module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
-      module segmented_iterator    { private header "__iterator/segmented_iterator.h" }
-      module size                  { private header "__iterator/size.h" }
-      module sortable {
+      module reverse_access         { private header "__iterator/reverse_access.h" }
+      module reverse_iterator       { private header "__iterator/reverse_iterator.h" }
+      module segmented_iterator     { private header "__iterator/segmented_iterator.h" }
+      module size                   { private header "__iterator/size.h" }
+      module sortable               {
         private header "__iterator/sortable.h"
         export functional.__functional.ranges_operations
       }
-      module unreachable_sentinel  { private header "__iterator/unreachable_sentinel.h" }
-      module wrap_iter             { private header "__iterator/wrap_iter.h" }
+      module unreachable_sentinel   { private header "__iterator/unreachable_sentinel.h" }
+      module wrap_iter              { private header "__iterator/wrap_iter.h" }
     }
   }
   module latch {
@@ -1301,62 +1302,65 @@
     export *
 
     module __ranges {
-      module access                 { private header "__ranges/access.h" }
-      module all                    {
+      module access                     { private header "__ranges/access.h" }
+      module all                        {
         private header "__ranges/all.h"
         export functional.__functional.compose
         export functional.__functional.perfect_forward
       }
-      module as_rvalue_view         { private header "__ranges/as_rvalue_view.h" }
-      module common_view            { private header "__ranges/common_view.h" }
-      module concepts               { private header "__ranges/concepts.h" }
-      module copyable_box           { private header "__ranges/copyable_box.h" }
-      module counted                {
+      module as_rvalue_view             { private header "__ranges/as_rvalue_view.h" }
+      module common_view                { private header "__ranges/common_view.h" }
+      module concepts                   { private header "__ranges/concepts.h" }
+      module container_compatible_range { private header "__ranges/container_compatible_range.h" }
+      module copyable_box               { private header "__ranges/copyable_box.h" }
+      module counted                    {
         private header "__ranges/counted.h"
         export span
       }
-      module dangling               { private header "__ranges/dangling.h" }
-      module data                   { private header "__ranges/data.h" }
-      module drop_view              { private header "__ranges/drop_view.h" }
-      module drop_while_view        { private header "__ranges/drop_while_view.h" }
-      module elements_view          { private header "__ranges/elements_view.h" }
-      module empty                  { private header "__ranges/empty.h" }
-      module empty_view             { private header "__ranges/empty_view.h" }
-      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 iota_view              { private header "__ranges/iota_view.h" }
-      module istream_view           {
+      module dangling                   { private header "__ranges/dangling.h" }
+      module data                       { private header "__ranges/data.h" }
+      module drop_view                  { private header "__ranges/drop_view.h" }
+      module drop_while_view            { private header "__ranges/drop_while_view.h" }
+      module elements_view              { private header "__ranges/elements_view.h" }
+      module empty                      { private header "__ranges/empty.h" }
+      module empty_view                 { private header "__ranges/empty_view.h" }
+      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@
         private header "__ranges/istream_view.h"
       }
-      module join_view              { private header "__ranges/join_view.h" }
-      module lazy_split_view        { private header "__ranges/lazy_split_view.h" }
-      module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
-      module owning_view            { private header "__ranges/owning_view.h" }
-      module range_adaptor          { private header "__ranges/range_adaptor.h" }
-      module rbegin                 { private header "__ranges/rbegin.h" }
-      module ref_view               { private header "__ranges/ref_view.h" }
-      module rend                   { private header "__ranges/rend.h" }
-      module reverse_view           { private header "__ranges/reverse_view.h" }
-      module single_view            { private header "__ranges/single_view.h" }
-      module size                   { private header "__ranges/size.h" }
-      module split_view             { private header "__ranges/split_view.h" }
-      module subrange               {
+      module join_view                  { private header "__ranges/join_view.h" }
+      module lazy_split_view            { private header "__ranges/lazy_split_view.h" }
+      module non_propagating_cache      { private header "__ranges/non_propagating_cache.h" }
+      module owning_view                { private header "__ranges/owning_view.h" }
+      module range_adaptor              { private header "__ranges/range_adaptor.h" }
+      module rbegin                     { private header "__ranges/rbegin.h" }
+      module ref_view                   { private header "__ranges/ref_view.h" }
+      module rend                       { private header "__ranges/rend.h" }
+      module reverse_view               { private header "__ranges/reverse_view.h" }
+      module single_view                { private header "__ranges/single_view.h" }
+      module size                       { private header "__ranges/size.h" }
+      module split_view                 { private header "__ranges/split_view.h" }
+      module subrange                   {
         private header "__ranges/subrange.h"
 
         module subrange_fwd { private header "__fwd/subrange.h" }
       }
-      module take_view              { private header "__ranges/take_view.h" }
-      module take_while_view        { private header "__ranges/take_while_view.h" }
-      module transform_view         {
+      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
         export functional.__functional.perfect_forward
       }
-      module view_interface         { private header "__ranges/view_interface.h" }
-      module views                  { private header "__ranges/views.h" }
-      module zip_view               { private header "__ranges/zip_view.h" }
+      module view_interface             { private header "__ranges/view_interface.h" }
+      module views                      { private header "__ranges/views.h" }
+      module zip_view                   { private header "__ranges/zip_view.h" }
     }
   }
   module ratio {
diff --git a/libcxx/include/queue b/libcxx/include/queue
--- a/libcxx/include/queue
+++ b/libcxx/include/queue
@@ -43,6 +43,7 @@
     explicit queue(container_type&& c)
     template<class InputIterator>
         queue(InputIterator first, InputIterator last); // since C++23
+    template<container-compatible-range<T> R> queue(from_range_t, R&& rg); // since C++23
     template <class Alloc>
         explicit queue(const Alloc& a);
     template <class Alloc>
@@ -55,6 +56,8 @@
         queue(queue&& q, const Alloc& a);
     template <class InputIterator, class Alloc>
         queue(InputIterator first, InputIterator last, const Alloc&); // since C++23
+    template<container-compatible-range<T> R, class Alloc>
+        queue(from_range_t, R&& rg, const Alloc&); // since C++23
 
     bool      empty() const;
     size_type size() const;
@@ -66,6 +69,8 @@
 
     void push(const value_type& v);
     void push(value_type&& v);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> reference emplace(Args&&... args); // reference in C++17
     void pop();
 
@@ -78,6 +83,9 @@
 template<class InputIterator>
   queue(InputIterator, InputIterator) -> queue<iter-value-type<InputIterator>>; // since C++23
 
+template<ranges::input_range R>
+  queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>; // since C++23
+
 template<class Container, class Allocator>
   queue(Container, Allocator) -> queue<typename Container::value_type, Container>; // C++17
 
@@ -86,6 +94,10 @@
   -> queue<iter-value-type<InputIterator>,
            deque<iter-value-type<InputIterator>, Allocator>>; // since C++23
 
+template<ranges::input_range R, class Allocator>
+    queue(from_range_t, R&&, Allocator)
+      -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
+
 template <class T, class Container>
   bool operator==(const queue<T, Container>& x,const queue<T, Container>& y);
 
@@ -138,6 +150,8 @@
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, Container&& c);
+    template <container-compatible-range<T> R>
+        priority_queue(from_range_t, R&& rg, const Compare& x = Compare()); // since C++23
     template <class Alloc>
         explicit priority_queue(const Alloc& a);
     template <class Alloc>
@@ -160,6 +174,10 @@
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, Container&& c, const Alloc& a);
+    template <container-compatible-range<T> R, class Alloc>
+      priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&); // since C++23
+    template <container-compatible-range<T> R, class Alloc>
+      priority_queue(from_range_t, R&& rg, const Alloc&); // since C++23
     template <class Alloc>
         priority_queue(const priority_queue& q, const Alloc& a);
     template <class Alloc>
@@ -171,6 +189,8 @@
 
     void push(const value_type& v);
     void push(value_type&& v);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> void emplace(Args&&... args);
     void pop();
 
@@ -189,6 +209,10 @@
 priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
     -> priority_queue<iter-value-type<InputIterator>, Container, Compare>; // C++17
 
+template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
+  priority_queue(from_range_t, R&&, Compare = Compare())
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>>, Compare>; // C++23
+
 template<class Compare, class Container, class Allocator>
 priority_queue(Compare, Container, Allocator)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
@@ -208,6 +232,15 @@
 priority_queue(InputIterator, InputIterator, Compare, Container, Allocator)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
 
+template<ranges::input_range R, class Compare, class Allocator>
+  priority_queue(from_range_t, R&&, Compare, Allocator)
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>,
+                        Compare>; // C++23
+
+template<ranges::input_range R, class Allocator>
+  priority_queue(from_range_t, R&&, Allocator)
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>>; // C++23
+
 template <class T, class Container, class Compare>
   void swap(priority_queue<T, Container, Compare>& x,
             priority_queue<T, Container, Compare>& y)
@@ -220,11 +253,17 @@
 #include <__algorithm/make_heap.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/push_heap.h>
+#include <__algorithm/ranges_copy.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/operations.h>
+#include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__utility/forward.h>
 #include <deque>
 #include <vector>
@@ -283,12 +322,24 @@
     _LIBCPP_HIDE_FROM_ABI
     queue(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
 
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    queue(from_range_t, _Range&& __range) : c(from_range, std::forward<_Range>(__range)) {}
+
     template <class _InputIterator,
               class _Alloc,
               class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
               class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
     _LIBCPP_HIDE_FROM_ABI
     queue(_InputIterator __first, _InputIterator __second, const _Alloc& __alloc) : c(__first, __second, __alloc) {}
+
+    template <_ContainerCompatibleRange<_Tp> _Range,
+              class _Alloc,
+              class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
+    _LIBCPP_HIDE_FROM_ABI
+    queue(from_range_t, _Range&& __range, const _Alloc& __alloc)
+      : c(from_range, std::forward<_Range>(__range), __alloc) {}
+
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
@@ -360,6 +411,21 @@
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void push(value_type&& __v)      {c.push_back(_VSTD::move(__v));}
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void push_range(_Range&& __range) {
+      if constexpr (requires (container_type& __c) {
+        __c.append_range(std::forward<_Range>(__range));
+      }) {
+        c.append_range(std::forward<_Range>(__range));
+      } else {
+        ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
+      }
+    }
+#endif
+
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
 #if _LIBCPP_STD_VER >= 17
@@ -418,12 +484,22 @@
 queue(_InputIterator, _InputIterator)
     -> queue<__iter_value_type<_InputIterator>>;
 
+template <ranges::input_range _Range>
+queue(from_range_t, _Range&&)
+    -> queue<ranges::range_value_t<_Range>>;
+
 template <class _InputIterator,
           class _Alloc,
           class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
           class = __enable_if_t<__is_allocator<_Alloc>::value>>
 queue(_InputIterator, _InputIterator, _Alloc)
     -> queue<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
+
+template <ranges::input_range _Range,
+          class _Alloc,
+          class = __enable_if_t<__is_allocator<_Alloc>::value>>
+queue(from_range_t, _Range&&, _Alloc)
+    -> queue<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
 #endif
 
 template <class _Tp, class _Container>
@@ -557,6 +633,17 @@
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, container_type&& __c);
 #endif // _LIBCPP_CXX03_LANG
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    priority_queue(from_range_t, _Range&& __range, const value_compare& __comp = value_compare())
+    : c(from_range, std::forward<_Range>(__range)),
+      comp(__comp) {
+      std::make_heap(c.begin(), c.end(), comp);
+    }
+#endif
+
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit priority_queue(const _Alloc& __a,
@@ -611,6 +698,30 @@
                        __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
 #endif  // _LIBCPP_CXX03_LANG
 
+#if _LIBCPP_STD_VER >= 23
+
+    template <_ContainerCompatibleRange<_Tp> _Range,
+              class _Alloc,
+              class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
+    _LIBCPP_HIDE_FROM_ABI
+    priority_queue(from_range_t, _Range&& __range, const value_compare& __comp, const _Alloc& __a)
+    : c(from_range, std::forward<_Range>(__range), __a),
+      comp(__comp) {
+      std::make_heap(c.begin(), c.end(), comp);
+    }
+
+    template <_ContainerCompatibleRange<_Tp> _Range,
+              class _Alloc,
+              class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
+    _LIBCPP_HIDE_FROM_ABI
+    priority_queue(from_range_t, _Range&& __range, const _Alloc& __a)
+    : c(from_range, std::forward<_Range>(__range), __a),
+      comp() {
+      std::make_heap(c.begin(), c.end(), comp);
+    }
+
+#endif
+
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool            empty() const {return c.empty();}
     _LIBCPP_INLINE_VISIBILITY
@@ -623,6 +734,23 @@
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void push(value_type&& __v);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void push_range(_Range&& __range) {
+      if constexpr (requires (container_type& __c) {
+        __c.append_range(std::forward<_Range>(__range));
+      }) {
+        c.append_range(std::forward<_Range>(__range));
+      } else {
+        ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
+      }
+
+      std::make_heap(c.begin(), c.end(), comp);
+    }
+#endif
+
     template <class... _Args>
     _LIBCPP_INLINE_VISIBILITY
     void emplace(_Args&&... __args);
@@ -695,6 +823,31 @@
     -> priority_queue<typename _Container::value_type, _Container, _Compare>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range,
+          class _Compare = less<ranges::range_value_t<_Range>>,
+          class = enable_if_t<!__is_allocator<_Compare>::value>>
+priority_queue(from_range_t, _Range&&, _Compare = _Compare())
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>>, _Compare>;
+
+template <ranges::input_range _Range,
+          class _Compare,
+          class _Alloc,
+          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<__is_allocator<_Alloc>::value>>
+priority_queue(from_range_t, _Range&&, _Compare, _Alloc)
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>,
+                        _Compare>;
+
+template <ranges::input_range _Range,
+          class _Alloc,
+          class = enable_if_t<__is_allocator<_Alloc>::value>>
+priority_queue(from_range_t, _Range&&, _Alloc)
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>>;
+
+#endif
+
 template <class _Tp, class _Container, class _Compare>
 inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp,
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -138,6 +138,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>
@@ -339,6 +349,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
 }
 */
 
@@ -360,6 +373,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>
@@ -373,6 +387,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/set b/libcxx/include/set
--- a/libcxx/include/set
+++ b/libcxx/include/set
@@ -56,6 +56,8 @@
     template <class InputIterator>
         set(InputIterator first, InputIterator last, const value_compare& comp,
             const allocator_type& a);
+    template<container-compatible-range<value_type> R>
+      set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
     set(const set& s);
     set(set&& s)
         noexcept(
@@ -70,6 +72,9 @@
     template <class InputIterator>
         set(InputIterator first, InputIterator last, const allocator_type& a)
             : set(first, last, Compare(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      set(from_range_t, R&& rg, const Allocator& a))
+        : set(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
     set(initializer_list<value_type> il, const allocator_type& a)
         : set(il, Compare(), a) {}  // C++14
     ~set();
@@ -114,6 +119,8 @@
     iterator insert(const_iterator position, value_type&& v);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type> il);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -190,6 +197,11 @@
     Compare = Compare(), Allocator = Allocator())
   -> set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; // C++17
 
+template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+    -> set<ranges::range_value_t<R>, Compare, Allocator>; // C++23
+
 template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
 set(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
   -> set<Key, Compare, Allocator>; // C++17
@@ -199,6 +211,10 @@
   -> set<typename iterator_traits<InputIterator>::value_type,
           less<typename iterator_traits<InputIterator>::value_type>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  set(from_range_t, R&&, Allocator)
+    -> set<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>; // C++23
+
 template<class Key, class Allocator>
 set(initializer_list<Key>, Allocator) -> set<Key, less<Key>, Allocator>; // C++17
 
@@ -280,6 +296,9 @@
     template <class InputIterator>
         multiset(InputIterator first, InputIterator last,
                  const value_compare& comp, const allocator_type& a);
+    template<container-compatible-range<value_type> R>
+      multiset(from_range_t, R&& rg,
+               const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
     multiset(const multiset& s);
     multiset(multiset&& s)
         noexcept(
@@ -294,6 +313,9 @@
     template <class InputIterator>
         multiset(InputIterator first, InputIterator last, const allocator_type& a)
             : set(first, last, Compare(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      multiset(from_range_t, R&& rg, const Allocator& a))
+        : multiset(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
     multiset(initializer_list<value_type> il, const allocator_type& a)
         : set(il, Compare(), a) {}  // C++14
     ~multiset();
@@ -338,6 +360,8 @@
     iterator insert(const_iterator position, value_type&& v);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type> il);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -415,6 +439,11 @@
     Compare = Compare(), Allocator = Allocator())
   -> multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; // C++17
 
+template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
+          class Allocator = allocator<ranges::range_value_t<R>>>
+  multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+    -> multiset<ranges::range_value_t<R>, Compare, Allocator>;
+
 template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
 multiset(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
   -> multiset<Key, Compare, Allocator>; // C++17
@@ -424,6 +453,10 @@
   -> multiset<typename iterator_traits<InputIterator>::value_type,
           less<typename iterator_traits<InputIterator>::value_type>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  multiset(from_range_t, R&&, Allocator)
+    -> multiset<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>;
+
 template<class Key, class Allocator>
 multiset(initializer_list<Key>, Allocator) -> multiset<Key, less<Key>, Allocator>; // C++17
 
@@ -479,10 +512,14 @@
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/ranges_iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__tree>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
@@ -593,6 +630,16 @@
             insert(__f, __l);
         }
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    set(from_range_t, _Range&& __range, const key_compare& __comp = key_compare(),
+        const allocator_type& __a = allocator_type())
+      : __tree_(__comp, __a) {
+      insert_range(std::forward<_Range>(__range));
+    }
+#endif
+
 #if _LIBCPP_STD_VER >= 14
         template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
@@ -600,6 +647,13 @@
             : set(__f, __l, key_compare(), __a) {}
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    set(from_range_t, _Range&& __range, const allocator_type& __a)
+      : set(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     set(const set& __s)
         : __tree_(__s.__tree_)
@@ -742,6 +796,17 @@
                 __tree_.__insert_unique(__e, *__f);
         }
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void insert_range(_Range&& __range) {
+      const_iterator __end = cend();
+      for (auto&& __element : __range) {
+        __tree_.__insert_unique(__end, std::forward<decltype(__element)>(__element));
+      }
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator,bool> insert(value_type&& __v)
@@ -937,6 +1002,15 @@
 set(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
   -> set<__iter_value_type<_InputIterator>, _Compare, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Compare = less<ranges::range_value_t<_Range>>,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class = enable_if_t<!__is_allocator<_Compare>::value, void>>
+set(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+  -> set<ranges::range_value_t<_Range>, _Compare, _Allocator>;
+#endif
+
 template<class _Key, class _Compare = less<_Key>,
          class _Allocator = allocator<_Key>,
          class = enable_if_t<!__is_allocator<_Compare>::value, void>,
@@ -951,6 +1025,13 @@
   -> set<__iter_value_type<_InputIterator>,
          less<__iter_value_type<_InputIterator>>, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+set(from_range_t, _Range&&, _Allocator)
+  -> set<ranges::range_value_t<_Range>, less<ranges::range_value_t<_Range>>, _Allocator>;
+#endif
+
 template<class _Key, class _Allocator,
          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
 set(initializer_list<_Key>, _Allocator)
@@ -1137,6 +1218,21 @@
             insert(__f, __l);
         }
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    multiset(from_range_t, _Range&& __range, const key_compare& __comp = key_compare(),
+        const allocator_type& __a = allocator_type())
+      : __tree_(__comp, __a) {
+      insert_range(std::forward<_Range>(__range));
+    }
+
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    multiset(from_range_t, _Range&& __range, const allocator_type& __a)
+      : multiset(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     multiset(const multiset& __s)
         : __tree_(__s.__tree_.value_comp(),
@@ -1278,6 +1374,17 @@
                 __tree_.__insert_multi(__e, *__f);
         }
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void insert_range(_Range&& __range) {
+      const_iterator __end = cend();
+      for (auto&& __element : __range) {
+        __tree_.__insert_multi(__end, std::forward<decltype(__element)>(__element));
+      }
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(value_type&& __v)
@@ -1473,6 +1580,15 @@
 multiset(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
   -> multiset<__iter_value_type<_InputIterator>, _Compare, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Compare = less<ranges::range_value_t<_Range>>,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class = enable_if_t<!__is_allocator<_Compare>::value, void>>
+multiset(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+  -> multiset<ranges::range_value_t<_Range>, _Compare, _Allocator>;
+#endif
+
 template<class _Key, class _Compare = less<_Key>,
          class _Allocator = allocator<_Key>,
          class = enable_if_t<__is_allocator<_Allocator>::value, void>,
@@ -1487,6 +1603,13 @@
   -> multiset<__iter_value_type<_InputIterator>,
          less<__iter_value_type<_InputIterator>>, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multiset(from_range_t, _Range&&, _Allocator)
+  -> multiset<ranges::range_value_t<_Range>, less<ranges::range_value_t<_Range>>, _Allocator>;
+#endif
+
 template<class _Key, class _Allocator,
          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
 multiset(initializer_list<_Key>, _Allocator)
diff --git a/libcxx/include/stack b/libcxx/include/stack
--- a/libcxx/include/stack
+++ b/libcxx/include/stack
@@ -42,6 +42,7 @@
     explicit stack(const container_type& c);
     explicit stack(container_type&& c);
     template <class InputIterator> stack(InputIterator first, InputIterator last); // since C++23
+    template<container-compatible-range<T> R> stack(from_range_t, R&& rg); // since C++23
     template <class Alloc> explicit stack(const Alloc& a);
     template <class Alloc> stack(const container_type& c, const Alloc& a);
     template <class Alloc> stack(container_type&& c, const Alloc& a);
@@ -49,6 +50,8 @@
     template <class Alloc> stack(stack&& c, const Alloc& a);
     template<class InputIterator, class Alloc>
     stack(InputIterator first, InputIterator last, const Alloc&); // since C++23
+    template<container-compatible-range<T> R, class Alloc>
+      stack(from_range_t, R&& rg, const Alloc&); // since C++23
 
     bool empty() const;
     size_type size() const;
@@ -57,6 +60,8 @@
 
     void push(const value_type& x);
     void push(value_type&& x);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> reference emplace(Args&&... args); // reference in C++17
     void pop();
 
@@ -69,6 +74,9 @@
 template<class InputIterator>
   stack(InputIterator, InputIterator) -> stack<iter-value-type<InputIterator>>; // since C++23
 
+template<ranges::input_range R>
+  stack(from_range_t, R&&) -> stack<ranges::range_value_t<R>>; // since C++23
+
 template<class Container, class Allocator>
   stack(Container, Allocator) -> stack<typename Container::value_type, Container>; // C++17
 
@@ -77,6 +85,10 @@
     -> stack<iter-value-type<InputIterator>,
              deque<iter-value-type<InputIterator>, Allocator>>; // since C++23
 
+template<ranges::input_range R, class Allocator>
+  stack(from_range_t, R&&, Allocator)
+    -> stack<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
+
 template <class T, class Container>
   bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
@@ -98,10 +110,16 @@
 
 */
 
+#include <__algorithm/ranges_copy.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/is_same.h>
 #include <__utility/forward.h>
 #include <deque>
@@ -210,12 +228,24 @@
     _LIBCPP_HIDE_FROM_ABI
     stack(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
 
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    stack(from_range_t, _Range&& __range) : c(from_range, std::forward<_Range>(__range)) {}
+
     template <class _InputIterator,
               class _Alloc,
               class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
               class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
     _LIBCPP_HIDE_FROM_ABI
     stack(_InputIterator __first, _InputIterator __last, const _Alloc& __alloc) : c(__first, __last, __alloc) {}
+
+    template <_ContainerCompatibleRange<_Tp> _Range,
+              class _Alloc,
+              class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
+    _LIBCPP_HIDE_FROM_ABI
+    stack(from_range_t, _Range&& __range, const _Alloc& __alloc)
+        : c(from_range, std::forward<_Range>(__range), __alloc) {}
+
 #endif
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
@@ -233,6 +263,20 @@
     _LIBCPP_INLINE_VISIBILITY
     void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void push_range(_Range&& __range) {
+      if constexpr (requires (container_type& __c) {
+        __c.append_range(std::forward<_Range>(__range));
+      }) {
+        c.append_range(std::forward<_Range>(__range));
+      } else {
+        ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
+      }
+    }
+#endif
+
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
 #if _LIBCPP_STD_VER >= 17
@@ -290,12 +334,22 @@
 stack(_InputIterator, _InputIterator)
     -> stack<__iter_value_type<_InputIterator>>;
 
+template <ranges::input_range _Range>
+stack(from_range_t, _Range&&) -> stack<ranges::range_value_t<_Range>>;
+
 template<class _InputIterator,
          class _Alloc,
          class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
          class = __enable_if_t<__is_allocator<_Alloc>::value>>
 stack(_InputIterator, _InputIterator, _Alloc)
     -> stack<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
+
+template <ranges::input_range _Range,
+          class _Alloc,
+          class = __enable_if_t<__is_allocator<_Alloc>::value>>
+stack(from_range_t, _Range&&, _Alloc)
+  -> stack<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
+
 #endif
 
 template <class _Tp, class _Container>
diff --git a/libcxx/include/string b/libcxx/include/string
--- a/libcxx/include/string
+++ b/libcxx/include/string
@@ -124,6 +124,8 @@
     template<class InputIterator>
         basic_string(InputIterator begin, InputIterator end,
                      const allocator_type& a = allocator_type());                               // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());           // since C++23
     basic_string(initializer_list<value_type>, const Allocator& = Allocator());                 // constexpr since C++20
     basic_string(const basic_string&, const Allocator&);                                        // constexpr since C++20
     basic_string(basic_string&&, const Allocator&);                                             // constexpr since C++20
@@ -200,6 +202,8 @@
     basic_string& append(size_type n, value_type c);                                            // constexpr since C++20
     template<class InputIterator>
         basic_string& append(InputIterator first, InputIterator last);                          // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& append_range(R&& rg);                                             // C++23
     basic_string& append(initializer_list<value_type>);                                         // constexpr since C++20
 
     void push_back(value_type c);                                                               // constexpr since C++20
@@ -221,6 +225,8 @@
     basic_string& assign(size_type n, value_type c);                                            // constexpr since C++20
     template<class InputIterator>
         basic_string& assign(InputIterator first, InputIterator last);                          // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& assign_range(R&& rg);                                             // C++23
     basic_string& assign(initializer_list<value_type>);                                         // constexpr since C++20
 
     basic_string& insert(size_type pos1, const basic_string& str);                              // constexpr since C++20
@@ -237,6 +243,8 @@
     iterator      insert(const_iterator p, size_type n, value_type c);                          // constexpr since C++20
     template<class InputIterator>
         iterator insert(const_iterator p, InputIterator first, InputIterator last);             // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr iterator insert_range(const_iterator p, R&& rg);                                // C++23
     iterator      insert(const_iterator p, initializer_list<value_type>);                       // constexpr since C++20
 
     basic_string& erase(size_type pos = 0, size_type n = npos);                                 // constexpr since C++20
@@ -262,6 +270,8 @@
     basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);     // constexpr since C++20
     template<class InputIterator>
         basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg); // C++23
     basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);  // constexpr since C++20
 
     size_type copy(value_type* s, size_type n, size_type pos = 0) const;                        // constexpr since C++20
@@ -354,6 +364,26 @@
                   char_traits<typename iterator_traits<InputIterator>::value_type>,
                   Allocator>;   // C++17
 
+template<ranges::input_range R,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  basic_string(from_range_t, R&&, Allocator = Allocator())
+    -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
+                    Allocator>; // C++23
+
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>; // C++17
+
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  basic_string(basic_string_view<charT, traits>,
+                typename see below::size_type, typename see below::size_type,
+                const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>; // C++17
+
 template<class charT, class traits, class Allocator>
 basic_string<charT, traits, Allocator>
 operator+(const basic_string<charT, traits, Allocator>& lhs,
@@ -559,6 +589,11 @@
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
+#include <__ranges/size.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
 #include <__type_traits/is_allocator.h>
@@ -660,6 +695,8 @@
 
 struct __uninitialized_size_tag {};
 
+struct __init_with_sentinel_tag {};
+
 template<class _CharT, class _Traits, class _Allocator>
 class basic_string
 {
@@ -820,6 +857,14 @@
         std::__debug_db_insert_c(this);
     }
 
+    template <class _Iter, class _Sent>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    basic_string(__init_with_sentinel_tag, _Iter __first, _Sent __last, const allocator_type& __a)
+        : __r_(__default_init_tag(), __a) {
+      __init_with_sentinel(__first, __last);
+      std::__debug_db_insert_c(this);
+    }
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator __make_iterator(pointer __p) {
         return iterator(this, __p);
     }
@@ -1046,6 +1091,21 @@
     std::__debug_db_insert_c(this);
   }
 
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  basic_string(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
+      : __r_(__default_init_tag(), __a) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      __init_with_size(ranges::begin(__range), ranges::end(__range), ranges::distance(__range));
+    } else {
+      __init_with_sentinel(ranges::begin(__range), ranges::end(__range));
+    }
+
+    std::__debug_db_insert_c(this);
+  }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(initializer_list<_CharT> __il)
       : __r_(__default_init_tag(), __default_init_tag()) {
@@ -1259,6 +1319,14 @@
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
     append(_ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr basic_string& append_range(_Range&& __range) {
+      return append(basic_string(from_range, std::forward<_Range>(__range), get_allocator()));
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
@@ -1322,6 +1390,24 @@
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
     assign(_ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr basic_string& assign_range(_Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        size_type __n = __string_is_trivial_iterator<ranges::iterator_t<_Range>>::value ?
+            static_cast<size_type>(ranges::distance(__range)) : 0;
+        __assign_with_size(ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+        assign(__temp.data(), __temp.size());
+      }
+
+      return *this;
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
@@ -1353,6 +1439,21 @@
   _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, size_type __n, value_type __c);
   _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __pos, value_type __c);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+        return insert(__position, __temp.data(), __temp.data() + __temp.size());
+      }
+    }
+#endif
+
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
   insert(const_iterator __pos, size_type __n, value_type __c) {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
@@ -1441,6 +1542,15 @@
   _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
   replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr basic_string& replace_with_range(const_iterator __i1, const_iterator __i2, _Range&& __range) {
+      basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+      return replace(__i1, __i2, __temp);
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
@@ -1699,9 +1809,17 @@
         return !__libcpp_is_constant_evaluated() && (__sz < __min_cap);
     }
 
-    template <class _ForwardIterator>
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_size(_Iterator __first, _Sentinel __last, size_type __n);
+
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
+
+    template <class _ForwardIterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) {
+    iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _Sentinel __last) {
         size_type __sz = size();
         size_type __cap = capacity();
         value_type* __p;
@@ -1726,6 +1844,10 @@
         return begin() + __ip;
     }
 
+    template<class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20
+    iterator __insert_with_size(const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n);
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 allocator_type& __alloc() _NOEXCEPT { return __r_.second(); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); }
 
@@ -1828,6 +1950,13 @@
     template <class _ForwardIterator, __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value, int> = 0>
     inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(_ForwardIterator __first, _ForwardIterator __last);
 
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __init_with_sentinel(_InputIterator __first, _Sentinel __last);
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __init_with_size(_InputIterator __first, _Sentinel __last, size_type __sz);
+
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
                    size_type __n_copy,  size_type __n_del,     size_type __n_add = 0);
@@ -2014,6 +2143,15 @@
   -> basic_string<_CharT, _Traits, _Allocator>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>
+          >
+basic_string(from_range_t, _Range&&, _Allocator = _Allocator())
+  -> basic_string<ranges::range_value_t<_Range>, char_traits<ranges::range_value_t<_Range>>, _Allocator>;
+#endif
+
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
@@ -2159,7 +2297,15 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
 {
+  __init_with_sentinel(__first, __last);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void basic_string<_CharT, _Traits, _Allocator>::__init_with_sentinel(_InputIterator __first, _Sentinel __last) {
     __default_init();
+
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
@@ -2182,16 +2328,27 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
+  size_type __sz = static_cast<size_type>(std::distance(__first, __last));
+  __init_with_size(__first, __last, __sz);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void basic_string<_CharT, _Traits, _Allocator>::__init_with_size(
+    _InputIterator __first, _Sentinel __last, size_type __sz) {
     if (__libcpp_is_constant_evaluated())
         __r_.first() = __rep();
-    size_type __sz = static_cast<size_type>(std::distance(__first, __last));
+
     if (__sz > max_size())
         __throw_length_error();
+
     pointer __p;
     if (__fits_in_sso(__sz))
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
+
     }
     else
     {
@@ -2447,9 +2604,17 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
-    const basic_string __temp(__first, __last, __alloc());
-    assign(__temp.data(), __temp.size());
-    return *this;
+  __assign_with_sentinel(__first, __last);
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void
+basic_string<_CharT, _Traits, _Allocator>::__assign_with_sentinel(_InputIterator __first, _Sentinel __last) {
+  const basic_string __temp(__init_with_sentinel_tag{}, __first, __last, __alloc());
+  assign(__temp.data(), __temp.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2457,11 +2622,24 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
+  if (__string_is_trivial_iterator<_ForwardIterator>::value) {
+      size_type __n = static_cast<size_type>(std::distance(__first, __last));
+    __assign_with_size(__first, __last, __n);
+  } else {
+    __assign_with_sentinel(__first, __last);
+  }
+
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+void
+basic_string<_CharT, _Traits, _Allocator>::__assign_with_size(_Iterator __first, _Sentinel __last, size_type __n) {
     size_type __cap = capacity();
-    size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ?
-        static_cast<size_type>(std::distance(__first, __last)) : 0;
 
-    if (__string_is_trivial_iterator<_ForwardIterator>::value &&
+    if (__string_is_trivial_iterator<_Iterator>::value &&
         (__cap >= __n || !__addr_in_range(*__first)))
     {
         if (__cap < __n)
@@ -2478,10 +2656,8 @@
     }
     else
     {
-        const basic_string __temp(__first, __last, __alloc());
-        assign(__temp.data(), __temp.size());
+      __assign_with_sentinel(__first, __last);
     }
-    return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2787,19 +2963,27 @@
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
                          "string::insert(iterator, range) called with an iterator not referring to this string");
+    auto __n = static_cast<size_type>(std::distance(__first, __last));
+    return __insert_with_size(__pos, __first, __last, __n);
+}
 
+template <class _CharT, class _Traits, class _Allocator>
+template<class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20
+typename basic_string<_CharT, _Traits, _Allocator>::iterator
+basic_string<_CharT, _Traits, _Allocator>::__insert_with_size(
+    const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n) {
     size_type __ip = static_cast<size_type>(__pos - begin());
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
     if (__n == 0)
         return begin() + __ip;
 
-    if (__string_is_trivial_iterator<_ForwardIterator>::value && !__addr_in_range(*__first))
+    if (__string_is_trivial_iterator<_Iterator>::value && !__addr_in_range(*__first))
     {
         return __insert_from_safe_copy(__n, __ip, __first, __last);
     }
     else
     {
-        const basic_string __temp(__first, __last, __alloc());
+        const basic_string __temp(__init_with_sentinel_tag{}, __first, __last, __alloc());
         return __insert_from_safe_copy(__n, __ip, __temp.begin(), __temp.end());
     }
 }
diff --git a/libcxx/include/unordered_map b/libcxx/include/unordered_map
--- a/libcxx/include/unordered_map
+++ b/libcxx/include/unordered_map
@@ -59,6 +59,11 @@
                       size_type n = 0, const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
+    template<container-compatible-range<value_type> R>
+      unordered_map(from_range_t, R&& rg, size_type n = see below,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type()); // C++23
+
     explicit unordered_map(const allocator_type&);
     unordered_map(const unordered_map&);
     unordered_map(const unordered_map&, const Allocator&);
@@ -82,6 +87,12 @@
       unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
         const allocator_type& a)
       : unordered_map(f, l, n, hf, key_equal(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
+        : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+    template<container-compatible-range<value_type> R>
+      unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+        : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
     unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_map(il, n, hasher(), key_equal(), a) {}  // C++14
     unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
@@ -122,6 +133,8 @@
         iterator insert(const_iterator hint, P&& obj);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type>);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -224,6 +237,13 @@
   -> unordered_map<iter_key_t<InputIterator>, iter_value_t<InputIterator>, Hash, Pred,
     Allocator>; // C++17
 
+template<ranges::input_range R, class Hash = hash<range-key-type<R>>,
+         class Pred = equal_to<range-key-type<R>>,
+         class Allocator = allocator<range-to-alloc-type<R>>>
+  unordered_map(from_range_t, R&&, typename see below::size_type = see below,
+                Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+    -> unordered_map<range-key-type<R>, range-mapped-type<R>, Hash, Pred, Allocator>; // C++23
+
 template<class Key, class T, class Hash = hash<Key>,
     class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
 unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type = see below,
@@ -245,6 +265,21 @@
   -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Hash,
           equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
+    -> unordered_map<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
+template<ranges::input_range R, class Allocator>
+  unordered_map(from_range_t, R&&, Allocator)
+    -> unordered_map<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
+template<ranges::input_range R, class Hash, class Allocator>
+  unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+    -> unordered_map<range-key-type<R>, range-mapped-type<R>, Hash,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
 template<class Key, class T, typename Allocator>
 unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type, Allocator)
   -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>; // C++17
@@ -311,6 +346,10 @@
                       size_type n = 0, const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
+    template<container-compatible-range<value_type> R>
+      unordered_multimap(from_range_t, R&& rg, size_type n = see below,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type()); // C++23
     explicit unordered_multimap(const allocator_type&);
     unordered_multimap(const unordered_multimap&);
     unordered_multimap(const unordered_multimap&, const Allocator&);
@@ -334,6 +373,12 @@
       unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
         const allocator_type& a)
       : unordered_multimap(f, l, n, hf, key_equal(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
+        : unordered_multimap(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+    template<container-compatible-range<value_type> R>
+      unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+        : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
     unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_multimap(il, n, hasher(), key_equal(), a) {}  // C++14
     unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
@@ -374,6 +419,8 @@
         iterator insert(const_iterator hint, P&& obj);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                               // C++23
     void insert(initializer_list<value_type>);
 
     node_type extract(const_iterator position);                // C++17
@@ -453,6 +500,13 @@
   -> unordered_multimap<iter_key_t<InputIterator>, iter_value_t<InputIterator>, Hash, Pred,
     Allocator>; // C++17
 
+template<ranges::input_range R, class Hash = hash<range-key-type<R>>,
+         class Pred = equal_to<range-key-type<R>>,
+         class Allocator = allocator<range-to-alloc-type<R>>>
+  unordered_multimap(from_range_t, R&&, typename see below::size_type = see below,
+                Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+    -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, Hash, Pred, Allocator>; // C++23
+
 template<class Key, class T, class Hash = hash<Key>,
     class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
 unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type = see below,
@@ -474,6 +528,21 @@
   -> unordered_multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Hash,
           equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  unordered_multimap(from_range_t, R&&, typename see below::size_type, Allocator)
+    -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
+template<ranges::input_range R, class Allocator>
+  unordered_multimap(from_range_t, R&&, Allocator)
+    -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
+template<ranges::input_range R, class Hash, class Allocator>
+  unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+    -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, Hash,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
 template<class Key, class T, typename Allocator>
 unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type, Allocator)
   -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>; // C++17
@@ -524,10 +593,14 @@
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/ranges_iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <stdexcept>
@@ -1107,6 +1180,23 @@
                       size_type __n, const hasher& __hf,
                       const key_equal& __eql,
                       const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_map(from_range_t, _Range&& __range, size_type __n = /*implementation-defined*/0,
+                  const hasher& __hf = hasher(), const key_equal& __eql = key_equal(),
+                  const allocator_type& __a = allocator_type())
+        : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+      std::__debug_db_insert_c(this);
+
+      if (__n > 0) {
+        __table_.__rehash_unique(__n);
+      }
+      insert_range(std::forward<_Range>(__range));
+    }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     explicit unordered_map(const allocator_type& __a);
     _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u);
@@ -1139,6 +1229,19 @@
       unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
         const allocator_type& __a)
       : unordered_map(__first, __last, __n, __hf, key_equal(), __a) {}
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_map(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
+        : unordered_map(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
+
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_map(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_map(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
       : unordered_map(__il, __n, hasher(), key_equal(), __a) {}
@@ -1217,6 +1320,16 @@
         _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void insert_range(_Range&& __range) {
+      for (auto&& __element : __range) {
+        __table_.__insert_unique(std::forward<decltype(__element)>(__element));
+      }
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
@@ -1563,6 +1676,20 @@
               _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
   -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Hash = hash<__range_key_type<_Range>>,
+          class _Pred = equal_to<__range_key_type<_Range>>,
+          class _Allocator = allocator<__range_to_alloc_type<_Range>>,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<!__is_allocator<_Pred>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_map<__range_key_type<_Range>, __range_mapped_type<_Range>, _Hash, _Pred, _Allocator>; // C++23
+#endif
+
 template<class _Key, class _Tp, class _Hash = hash<remove_const_t<_Key>>,
          class _Pred = equal_to<remove_const_t<_Key>>,
          class _Allocator = allocator<pair<const _Key, _Tp>>,
@@ -1597,6 +1724,29 @@
   -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
                    _Hash, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_map<__range_key_type<_Range>, __range_mapped_type<_Range>, hash<__range_key_type<_Range>>,
+                   equal_to<__range_key_type<_Range>>, _Allocator>;
+
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(from_range_t, _Range&&, _Allocator)
+  -> unordered_map<__range_key_type<_Range>, __range_mapped_type<_Range>, hash<__range_key_type<_Range>>,
+                   equal_to<__range_key_type<_Range>>, _Allocator>;
+
+template <ranges::input_range _Range, class _Hash, class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_map<__range_key_type<_Range>, __range_mapped_type<_Range>, _Hash,
+                   equal_to<__range_key_type<_Range>>, _Allocator>;
+
+#endif
+
 template<class _Key, class _Tp, class _Allocator,
          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
@@ -1998,6 +2148,23 @@
                       size_type __n, const hasher& __hf,
                       const key_equal& __eql,
                       const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_multimap(from_range_t, _Range&& __range, size_type __n = /*implementation-defined*/0,
+                       const hasher& __hf = hasher(), const key_equal& __eql = key_equal(),
+                       const allocator_type& __a = allocator_type())
+        : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+      std::__debug_db_insert_c(this);
+
+      if (__n > 0) {
+        __table_.__rehash_multi(__n);
+      }
+      insert_range(std::forward<_Range>(__range));
+    }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     explicit unordered_multimap(const allocator_type& __a);
     _LIBCPP_HIDE_FROM_ABI unordered_multimap(const unordered_multimap& __u);
@@ -2031,6 +2198,19 @@
       unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
         const allocator_type& __a)
       : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) {}
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_multimap(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
+        : unordered_multimap(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
+
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_multimap(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_multimap(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
       : unordered_multimap(__il, __n, hasher(), key_equal(), __a) {}
@@ -2104,6 +2284,16 @@
     _LIBCPP_INLINE_VISIBILITY
     void insert(_InputIterator __first, _InputIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void insert_range(_Range&& __range) {
+      for (auto&& __element : __range) {
+        __table_.__insert_multi(std::forward<decltype(__element)>(__element));
+      }
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
@@ -2339,6 +2529,20 @@
                    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
   -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Hash = hash<__range_key_type<_Range>>,
+          class _Pred = equal_to<__range_key_type<_Range>>,
+          class _Allocator = allocator<__range_to_alloc_type<_Range>>,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<!__is_allocator<_Pred>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, _Hash, _Pred, _Allocator>;
+#endif
+
 template<class _Key, class _Tp, class _Hash = hash<remove_const_t<_Key>>,
          class _Pred = equal_to<remove_const_t<_Key>>,
          class _Allocator = allocator<pair<const _Key, _Tp>>,
@@ -2373,6 +2577,28 @@
   -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
                         _Hash, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, hash<__range_key_type<_Range>>,
+                   equal_to<__range_key_type<_Range>>, _Allocator>;
+
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(from_range_t, _Range&&, _Allocator)
+  -> unordered_multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, hash<__range_key_type<_Range>>,
+                   equal_to<__range_key_type<_Range>>, _Allocator>;
+
+template <ranges::input_range _Range, class _Hash, class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, _Hash,
+                   equal_to<__range_key_type<_Range>>, _Allocator>;
+
+#endif
 template<class _Key, class _Tp, class _Allocator,
          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
diff --git a/libcxx/include/unordered_set b/libcxx/include/unordered_set
--- a/libcxx/include/unordered_set
+++ b/libcxx/include/unordered_set
@@ -58,6 +58,10 @@
                       size_type n = 0, const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
+    template<container-compatible-range<value_type> R>
+      unordered_set(from_range_t, R&& rg, size_type n = see below,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type()); // C++23
     explicit unordered_set(const allocator_type&);
     unordered_set(const unordered_set&);
     unordered_set(const unordered_set&, const Allocator&);
@@ -77,6 +81,12 @@
     template <class InputIterator>
       unordered_set(InputIterator f, InputIterator l, size_type n,
                     const hasher& hf,  const allocator_type& a); // C++14
+    template<container-compatible-range<value_type> R>
+      unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
+        : unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+    template<container-compatible-range<value_type> R>
+      unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+        : unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
     unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
     unordered_set(initializer_list<value_type> il, size_type n,
                   const hasher& hf,  const allocator_type& a); // C++14
@@ -113,6 +123,8 @@
     iterator insert(const_iterator hint, value_type&& obj);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                      // C++23
     void insert(initializer_list<value_type>);
 
     node_type extract(const_iterator position);                       // C++17
@@ -191,6 +203,13 @@
   -> unordered_set<typename iterator_traits<InputIterator>::value_type,
         Hash, Pred, Allocator>; // C++17
 
+template<ranges::input_range R,
+         class Hash = hash<ranges::range_value_t<R>>,
+         class Pred = equal_to<ranges::range_value_t<R>>,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  unordered_set(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+    -> unordered_set<ranges::range_value_t<R>, Hash, Pred, Allocator>; // C++23
+
 template<class T, class Hash = hash<T>,
           class Pred = equal_to<T>, class Allocator = allocator<T>>
 unordered_set(initializer_list<T>, typename see below::size_type = see below,
@@ -211,6 +230,21 @@
         equal_to<typename iterator_traits<InputIterator>::value_type>,
         Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  unordered_set(from_range_t, R&&, typename see below::size_type, Allocator)
+    -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
+template<ranges::input_range R, class Allocator>
+  unordered_set(from_range_t, R&&, Allocator)
+    -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
+template<ranges::input_range R, class Hash, class Allocator>
+  unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+    -> unordered_set<ranges::range_value_t<R>, Hash,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
 template<class T, class Allocator>
 unordered_set(initializer_list<T>, typename see below::size_type, Allocator)
   -> unordered_set<T, hash<T>, equal_to<T>, Allocator>; // C++17
@@ -272,6 +306,10 @@
                       size_type n = 0, const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
+    template<container-compatible-range<value_type> R>
+      unordered_multiset(from_range_t, R&& rg, size_type n = see below,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type()); // C++23
     explicit unordered_multiset(const allocator_type&);
     unordered_multiset(const unordered_multiset&);
     unordered_multiset(const unordered_multiset&, const Allocator&);
@@ -291,6 +329,12 @@
     template <class InputIterator>
       unordered_multiset(InputIterator f, InputIterator l, size_type n,
                          const hasher& hf, const allocator_type& a); // C++14
+    template<container-compatible-range<value_type> R>
+      unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a)
+        : unordered_multiset(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+    template<container-compatible-range<value_type> R>
+      unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+        : unordered_multiset(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
     unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
     unordered_multiset(initializer_list<value_type> il, size_type n,
                        const hasher& hf,  const allocator_type& a); // C++14
@@ -327,6 +371,8 @@
     iterator insert(const_iterator hint, value_type&& obj);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                            // C++23
     void insert(initializer_list<value_type>);
 
     node_type extract(const_iterator position);             // C++17
@@ -405,6 +451,13 @@
   -> unordered_multiset<typename iterator_traits<InputIterator>::value_type,
         Hash, Pred, Allocator>; // C++17
 
+template<ranges::input_range R,
+         class Hash = hash<ranges::range_value_t<R>>,
+         class Pred = equal_to<ranges::range_value_t<R>>,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  unordered_multiset(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+    -> unordered_multiset<ranges::range_value_t<R>, Hash, Pred, Allocator>; // C++23
+
 template<class T, class Hash = hash<T>,
           class Pred = equal_to<T>, class Allocator = allocator<T>>
 unordered_multiset(initializer_list<T>, typename see below::size_type = see below,
@@ -424,6 +477,21 @@
   -> unordered_multiset<typename iterator_traits<InputIterator>::value_type, Hash,
         equal_to<typename iterator_traits<InputIterator>::value_type>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  unordered_multiset(from_range_t, R&&, typename see below::size_type, Allocator)
+    -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
+template<ranges::input_range R, class Allocator>
+  unordered_multiset(from_range_t, R&&, Allocator)
+    -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
+template<ranges::input_range R, class Hash, class Allocator>
+  unordered_multiset(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+    -> unordered_multiset<ranges::range_value_t<R>, Hash,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
 template<class T, class Allocator>
 unordered_multiset(initializer_list<T>, typename see below::size_type, Allocator)
   -> unordered_multiset<T, hash<T>, equal_to<T>, Allocator>; // C++17
@@ -469,10 +537,14 @@
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/ranges_iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <version>
@@ -573,6 +645,23 @@
     _LIBCPP_HIDE_FROM_ABI unordered_set(_InputIterator __first, _InputIterator __last,
                       size_type __n, const hasher& __hf, const key_equal& __eql,
                       const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_set(from_range_t, _Range&& __range, size_type __n = /*implementation-defined*/0,
+                  const hasher& __hf = hasher(), const key_equal& __eql = key_equal(),
+                  const allocator_type& __a = allocator_type())
+    : __table_(__hf, __eql, __a) {
+      std::__debug_db_insert_c(this);
+
+      if (__n > 0) {
+        __table_.__rehash_unique(__n);
+      }
+      insert_range(std::forward<_Range>(__range));
+    }
+#endif
+
 #if _LIBCPP_STD_VER >= 14
     template <class _InputIterator>
     inline _LIBCPP_INLINE_VISIBILITY
@@ -584,6 +673,19 @@
                       size_type __n, const hasher& __hf, const allocator_type& __a)
             : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}
 #endif
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_set(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
+        : unordered_set(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
+
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_set(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_set(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     explicit unordered_set(const allocator_type& __a);
     _LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u);
@@ -701,6 +803,16 @@
         _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void insert_range(_Range&& __range) {
+      for (auto&& __element : __range) {
+        __table_.__insert_unique(std::forward<decltype(__element)>(__element));
+      }
+    }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     iterator erase(const_iterator __p) {return __table_.erase(__p);}
     _LIBCPP_INLINE_VISIBILITY
@@ -893,6 +1005,20 @@
               _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
   -> unordered_set<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Hash = hash<ranges::range_value_t<_Range>>,
+          class _Pred = equal_to<ranges::range_value_t<_Range>>,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<!__is_allocator<_Pred>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_set<ranges::range_value_t<_Range>, _Hash, _Pred, _Allocator>; // C++23
+#endif
+
 template<class _Tp, class _Hash = hash<_Tp>,
          class _Pred = equal_to<_Tp>,
          class _Allocator = allocator<_Tp>,
@@ -925,6 +1051,28 @@
                    equal_to<__iter_value_type<_InputIterator>>,
                    _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_set<ranges::range_value_t<_Range>, hash<ranges::range_value_t<_Range>>,
+                   equal_to<ranges::range_value_t<_Range>>, _Allocator>;
+
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(from_range_t, _Range&&, _Allocator)
+  -> unordered_set<ranges::range_value_t<_Range>, hash<ranges::range_value_t<_Range>>,
+                   equal_to<ranges::range_value_t<_Range>>, _Allocator>;
+
+template <ranges::input_range _Range, class _Hash, class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_set<ranges::range_value_t<_Range>, _Hash, equal_to<ranges::range_value_t<_Range>>, _Allocator>;
+
+#endif
+
 template<class _Tp, class _Allocator,
          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
@@ -1228,6 +1376,23 @@
     _LIBCPP_HIDE_FROM_ABI unordered_multiset(_InputIterator __first, _InputIterator __last,
                       size_type __n , const hasher& __hf,
                       const key_equal& __eql, const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_multiset(from_range_t, _Range&& __range, size_type __n = /*implementation-defined*/0,
+                  const hasher& __hf = hasher(), const key_equal& __eql = key_equal(),
+                  const allocator_type& __a = allocator_type())
+    : __table_(__hf, __eql, __a) {
+      std::__debug_db_insert_c(this);
+
+      if (__n > 0) {
+        __table_.__rehash_multi(__n);
+      }
+      insert_range(std::forward<_Range>(__range));
+    }
+#endif
+
 #if _LIBCPP_STD_VER >= 14
     template <class _InputIterator>
     inline _LIBCPP_INLINE_VISIBILITY
@@ -1240,6 +1405,19 @@
                        size_type __n, const hasher& __hf, const allocator_type& __a)
         : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}
 #endif
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_multiset(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
+        : unordered_multiset(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
+
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    unordered_multiset(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_multiset(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     explicit unordered_multiset(const allocator_type& __a);
     _LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u);
@@ -1338,6 +1516,16 @@
         _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __first, _InputIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<value_type> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void insert_range(_Range&& __range) {
+      for (auto&& __element : __range) {
+        __table_.__insert_multi(std::forward<decltype(__element)>(__element));
+      }
+    }
+#endif
+
 #if _LIBCPP_STD_VER >= 17
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(node_type&& __nh)
@@ -1531,6 +1719,20 @@
               _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
   -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Hash = hash<ranges::range_value_t<_Range>>,
+          class _Pred = equal_to<ranges::range_value_t<_Range>>,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<!__is_allocator<_Pred>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_multiset<ranges::range_value_t<_Range>, _Hash, _Pred, _Allocator>; // C++23
+#endif
+
 template<class _Tp, class _Hash = hash<_Tp>,
          class _Pred = equal_to<_Tp>, class _Allocator = allocator<_Tp>,
          class = enable_if_t<!__is_allocator<_Hash>::value>,
@@ -1561,6 +1763,28 @@
                    equal_to<__iter_value_type<_InputIterator>>,
                    _Allocator>;
 
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_multiset<ranges::range_value_t<_Range>, hash<ranges::range_value_t<_Range>>,
+                   equal_to<ranges::range_value_t<_Range>>, _Allocator>;
+
+template <ranges::input_range _Range, class _Allocator,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(from_range_t, _Range&&, _Allocator)
+  -> unordered_multiset<ranges::range_value_t<_Range>, hash<ranges::range_value_t<_Range>>,
+                   equal_to<ranges::range_value_t<_Range>>, _Allocator>;
+
+template <ranges::input_range _Range, class _Hash, class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_multiset<ranges::range_value_t<_Range>, _Hash, equal_to<ranges::range_value_t<_Range>>, _Allocator>;
+
+#endif
+
 template<class _Tp, class _Allocator,
          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
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);
@@ -55,6 +57,8 @@
     vector& operator=(initializer_list<value_type> il);
     template <class InputIterator>
         void assign(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      constexpr void assign_range(R&& rg); // C++23
     void assign(size_type n, const value_type& u);
     void assign(initializer_list<value_type> il);
 
@@ -99,6 +103,8 @@
     void push_back(value_type&& x);
     template <class... Args>
         reference emplace_back(Args&&... args); // reference in C++17
+    template<container-compatible-range<T> R>
+      constexpr void append_range(R&& rg); // C++23
     void pop_back();
 
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
@@ -107,6 +113,8 @@
     iterator insert(const_iterator position, size_type n, const value_type& x);
     template <class InputIterator>
         iterator insert(const_iterator position, InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
     iterator insert(const_iterator position, initializer_list<value_type> il);
 
     iterator erase(const_iterator position);
@@ -165,6 +173,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<bool> R>
+      constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
     vector(const vector& x);
     vector(vector&& x)
         noexcept(is_nothrow_move_constructible<allocator_type>::value);
@@ -179,6 +189,8 @@
     vector& operator=(initializer_list<value_type> il);
     template <class InputIterator>
         void assign(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      constexpr void assign_range(R&& rg); // C++23
     void assign(size_type n, const value_type& u);
     void assign(initializer_list<value_type> il);
 
@@ -218,6 +230,8 @@
 
     void push_back(const value_type& x);
     template <class... Args> reference emplace_back(Args&&... args);  // C++14; reference in C++17
+    template<container-compatible-range<T> R>
+      constexpr void append_range(R&& rg); // C++23
     void pop_back();
 
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);  // C++14
@@ -225,6 +239,8 @@
     iterator insert(const_iterator position, size_type n, const value_type& x);
     template <class InputIterator>
         iterator insert(const_iterator position, InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
     iterator insert(const_iterator position, initializer_list<value_type> il);
 
     iterator erase(const_iterator position);
@@ -247,6 +263,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);
@@ -282,6 +302,7 @@
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/iterator_operations.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/rotate.h>
@@ -296,6 +317,7 @@
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__iterator/advance.h>
+#include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
@@ -306,6 +328,11 @@
 #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/container_compatible_range.h>
+#include <__ranges/from_range.h>
+#include <__ranges/size.h>
 #include <__split_buffer>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_constructible.h>
@@ -435,6 +462,20 @@
   _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) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      __init_with_size(ranges::begin(__range), ranges::end(__range), __n);
+
+    } else {
+      __init_with_sentinel(ranges::begin(__range), ranges::end(__range));
+    }
+  }
+#endif
+
 private:
   class __destroy_vector {
     public:
@@ -500,6 +541,20 @@
                     int> = 0>
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void assign(_ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr void assign_range(_Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        __assign_with_size(ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
     _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const_reference __u);
 
 #ifndef _LIBCPP_CXX03_LANG
@@ -602,6 +657,14 @@
         void      emplace_back(_Args&&... __args);
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr void append_range(_Range&& __range) {
+      insert_range(end(), std::forward<_Range>(__range));
+    }
+#endif
+
     _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
     void pop_back();
 
@@ -621,6 +684,20 @@
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
   insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
   template <
       class _ForwardIterator,
       __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
@@ -700,9 +777,51 @@
     _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 _InputIterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __init_with_size(_InputIterator __first, _Sentinel __last, size_type __n) {
+      auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+      std::__debug_db_insert_c(this);
+
+      if (__n > 0) {
+        __vallocate(__n);
+        __construct_at_end(__first, __last, __n);
+      }
+
+      __guard.__complete();
+    }
+
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __init_with_sentinel(_InputIterator __first, _Sentinel __last) {
+      auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+      std::__debug_db_insert_c(this);
+
+      for (; __first != __last; ++__first)
+        emplace_back(*__first);
+
+      __guard.__complete();
+    }
+
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
+
+    template <class _ForwardIterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __n);
+
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last);
+
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);
+
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __construct_at_end(_InputIterator __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);
@@ -909,6 +1028,15 @@
   -> vector<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Alloc = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Alloc>::value>
+          >
+vector(from_range_t, _Range&&, _Alloc = _Alloc())
+  -> vector<ranges::range_value_t<_Range>, _Alloc>;
+#endif
+
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
@@ -1023,10 +1151,9 @@
 }
 
 template <class _Tp, class _Allocator>
-template <class _ForwardIterator, __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value, int> >
+template <class _InputIterator, 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(_InputIterator __first, _Sentinel __last, size_type __n) {
   _ConstructTransaction __tx(*this, __n);
   __tx.__pos_ = std::__uninitialized_allocator_copy(__alloc(), __first, __last, __tx.__pos_);
 }
@@ -1123,11 +1250,7 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last)
 {
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    for (; __first != __last; ++__first)
-        emplace_back(*__first);
-    __guard.__complete();
+  __init_with_sentinel(__first, __last);
 }
 
 template <class _Tp, class _Allocator>
@@ -1138,11 +1261,7 @@
 vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a)
     : __end_cap_(nullptr, __a)
 {
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    for (; __first != __last; ++__first)
-        emplace_back(*__first);
-    __guard.__complete();
+  __init_with_sentinel(__first, __last);
 }
 
 template <class _Tp, class _Allocator>
@@ -1152,15 +1271,8 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last)
 {
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__first, __last, __n);
-    }
-    __guard.__complete();
+  size_type __n = static_cast<size_type>(std::distance(__first, __last));
+  __init_with_size(__first, __last, __n);
 }
 
 template <class _Tp, class _Allocator>
@@ -1171,15 +1283,8 @@
 vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a)
     : __end_cap_(nullptr, __a)
 {
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__first, __last, __n);
-    }
-    __guard.__complete();
+  size_type __n = static_cast<size_type>(std::distance(__first, __last));
+  __init_with_size(__first, __last, __n);
 }
 
 template <class _Tp, class _Allocator>
@@ -1187,15 +1292,7 @@
 vector<_Tp, _Allocator>::vector(const vector& __x)
     : __end_cap_(nullptr, __alloc_traits::select_on_container_copy_construction(__x.__alloc()))
 {
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    size_type __n = __x.size();
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__x.__begin_, __x.__end_, __n);
-    }
-    __guard.__complete();
+  __init_with_size(__x.__begin_, __x.__end_, __x.size());
 }
 
 template <class _Tp, class _Allocator>
@@ -1203,15 +1300,7 @@
 vector<_Tp, _Allocator>::vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
     : __end_cap_(nullptr, __a)
 {
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    size_type __n = __x.size();
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__x.__begin_, __x.__end_, __n);
-    }
-    __guard.__complete();
+  __init_with_size(__x.__begin_, __x.__end_, __x.size());
 }
 
 template <class _Tp, class _Allocator>
@@ -1355,6 +1444,13 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
+  __assign_with_sentinel(__first, __last);
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+void vector<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __last) {
     clear();
     for (; __first != __last; ++__first)
         emplace_back(*__first);
@@ -1367,22 +1463,27 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
-    size_type __new_size = static_cast<size_type>(std::distance(__first, __last));
+  __assign_with_size(__first, __last, std::distance(__first, __last));
+}
+
+template <class _Tp, class _Allocator>
+template <class _ForwardIterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+void vector<_Tp, _Allocator>::__assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __n) {
+    size_type __new_size = static_cast<size_type>(__n);
     if (__new_size <= capacity())
     {
-        _ForwardIterator __mid = __last;
-        bool __growing = false;
         if (__new_size > size())
         {
-            __growing = true;
-            __mid =  __first;
-            std::advance(__mid, size());
-        }
-        pointer __m = std::copy(__first, __mid, this->__begin_);
-        if (__growing)
+            _ForwardIterator __mid = std::next(__first, size());
+            std::copy(__first, __mid, this->__begin_);
             __construct_at_end(__mid, __last, __new_size - size());
+        }
         else
+        {
+            pointer __m = std::__copy<_ClassicAlgPolicy>(__first, __last, this->__begin_).second;
             this->__destruct_at_end(__m);
+        }
     }
     else
     {
@@ -1812,7 +1913,6 @@
     }
     return __make_iter(__p);
 }
-
 template <class _Tp, class _Allocator>
 template <class _InputIterator, __enable_if_t<__is_exactly_cpp17_input_iterator<_InputIterator>::value &&
                               is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
@@ -1820,8 +1920,17 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
 {
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                         "vector::insert(iterator, range) called with an iterator not referring to this vector");
+  return __insert_with_sentinel(__position, __first, __last);
+}
+
+template <class _Tp, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last) {
+  _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
+                        "vector::insert called with an iterator not referring to this vector");
+
     difference_type __off = __position - begin();
     pointer __p = this->__begin_ + __off;
     allocator_type& __a = this->__alloc();
@@ -1837,7 +1946,7 @@
         try
         {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __v.__construct_at_end(__first, __last);
+            __v.__construct_at_end_with_sentinel(std::move(__first), std::move(__last));
             difference_type __old_size = __old_last - this->__begin_;
             difference_type __old_p = __p - this->__begin_;
             reserve(__recommend(size() + __v.size()));
@@ -1865,17 +1974,27 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
 {
+  return __insert_with_size(__position, __first, __last, std::distance(__first, __last));
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::__insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last,
+                                            difference_type __n) {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                         "vector::insert(iterator, range) called with an iterator not referring to this vector");
+                        "vector::insert called with an iterator not referring to this vector");
+
+    auto __insertion_size = __n;
     pointer __p = this->__begin_ + (__position - begin());
-    difference_type __n = std::distance(__first, __last);
     if (__n > 0)
     {
         if (__n <= this->__end_cap() - this->__end_)
         {
             size_type __old_n = __n;
             pointer __old_last = this->__end_;
-            _ForwardIterator __m = __last;
+            _Iterator __m = std::next(__first, __n);
             difference_type __dx = this->__end_ - __p;
             if (__n > __dx)
             {
@@ -1895,7 +2014,7 @@
         {
             allocator_type& __a = this->__alloc();
             __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
-            __v.__construct_at_end(__first, __last);
+            __v.__construct_at_end_with_size(__first, __insertion_size);
             __p = __swap_out_circular_buffer(__v, __p);
         }
     }
@@ -2143,6 +2262,23 @@
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<bool> _Range>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    vector(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
+    : __begin_(nullptr),
+      __size_(0),
+      __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        __init_with_size(ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        __init_with_sentinel(ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v);
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v, const allocator_type& __a);
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector& operator=(const vector& __v);
@@ -2182,6 +2318,20 @@
         >::type
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 assign(_ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<bool> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr void assign_range(_Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        __assign_with_size(ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void assign(size_type __n, const value_type& __x);
 
 #ifndef _LIBCPP_CXX03_LANG
@@ -2271,6 +2421,14 @@
     }
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<bool> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr void append_range(_Range&& __range) {
+      insert_range(end(), std::forward<_Range>(__range));
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back() {--__size_;}
 
 #if _LIBCPP_STD_VER >= 14
@@ -2294,6 +2452,20 @@
         >::type
         _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<bool> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     iterator insert(const_iterator __position, initializer_list<value_type> __il)
@@ -2331,6 +2503,53 @@
         std::__throw_out_of_range("vector");
     }
 
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __init_with_size(_InputIterator __first, _Sentinel __last, size_type __n) {
+      auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+
+      if (__n > 0) {
+        __vallocate(__n);
+        __construct_at_end(std::move(__first), std::move(__last), __n);
+      }
+
+      __guard.__complete();
+    }
+
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __init_with_sentinel(_InputIterator __first, _Sentinel __last) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+        for (; __first != __last; ++__first)
+            push_back(*__first);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
+        if (__begin_ != nullptr)
+          __storage_traits::deallocate(__alloc(), __begin_, __cap());
+        std::__debug_db_invalidate_all(this);
+        throw;
+      }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    }
+
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
+
+  template <class _ForwardIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  void __assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __ns);
+
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  iterator __insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last);
+
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  iterator __insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);
+
     //  Allocate space for __n objects
     //  throws length_error if __n > max_size()
     //  throws (probably bad_alloc) if memory run out
@@ -2357,13 +2576,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 _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __construct_at_end(_InputIterator __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
@@ -2493,17 +2708,11 @@
 }
 
 template <class _Allocator>
-template <class _ForwardIterator>
+template <class _InputIterator, 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(_InputIterator __first, _Sentinel __last, size_type __n) {
     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)
@@ -2511,7 +2720,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>
@@ -2605,22 +2814,7 @@
       __size_(0),
       __cap_alloc_(0, __default_init_tag())
 {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        for (; __first != __last; ++__first)
-            push_back(*__first);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        if (__begin_ != nullptr)
-            __storage_traits::deallocate(__alloc(), __begin_, __cap());
-        std::__debug_db_invalidate_all(this);
-        throw;
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  __init_with_sentinel(__first, __last);
 }
 
 template <class _Allocator>
@@ -2632,22 +2826,7 @@
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        for (; __first != __last; ++__first)
-            push_back(*__first);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        if (__begin_ != nullptr)
-            __storage_traits::deallocate(__alloc(), __begin_, __cap());
-        std::__debug_db_invalidate_all(this);
-        throw;
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  __init_with_sentinel(__first, __last);
 }
 
 template <class _Allocator>
@@ -2659,14 +2838,8 @@
       __size_(0),
       __cap_alloc_(0, __default_init_tag())
 {
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__first, __last);
-    }
-    __guard.__complete();
+  auto __n = static_cast<size_type>(std::distance(__first, __last));
+  __init_with_size(__first, __last, __n);
 }
 
 template <class _Allocator>
@@ -2678,14 +2851,8 @@
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__first, __last);
-    }
-    __guard.__complete();
+  auto __n = static_cast<size_type>(std::distance(__first, __last));
+  __init_with_size(__first, __last, __n);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
@@ -2701,7 +2868,7 @@
     if (__n > 0)
     {
         __vallocate(__n);
-        __construct_at_end(__il.begin(), __il.end());
+        __construct_at_end(__il.begin(), __il.end(), __il.size());
     }
 }
 
@@ -2716,7 +2883,7 @@
     if (__n > 0)
     {
         __vallocate(__n);
-        __construct_at_end(__il.begin(), __il.end());
+        __construct_at_end(__il.begin(), __il.end(), __il.size());
     }
 }
 
@@ -2732,7 +2899,7 @@
     if (__v.size() > 0)
     {
         __vallocate(__v.size());
-        __construct_at_end(__v.begin(), __v.end());
+        __construct_at_end(__v.begin(), __v.end(), __v.size());
     }
 }
 
@@ -2746,7 +2913,7 @@
     if (__v.size() > 0)
     {
         __vallocate(__v.size());
-        __construct_at_end(__v.begin(), __v.end());
+        __construct_at_end(__v.begin(), __v.end(), __v.size());
     }
 }
 
@@ -2805,7 +2972,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());
     }
 }
 
@@ -2873,6 +3040,13 @@
 >::type
 vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
+  __assign_with_sentinel(__first, __last);
+}
+
+template <class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+void vector<bool, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __last) {
     clear();
     for (; __first != __last; ++__first)
         push_back(*__first);
@@ -2888,9 +3062,17 @@
 >::type
 vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
-    clear();
-    difference_type __ns = std::distance(__first, __last);
+  __assign_with_size(__first, __last, std::distance(__first, __last));
+}
+
+template <class _Allocator>
+template <class _ForwardIterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+void vector<bool, _Allocator>::__assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __ns) {
     _LIBCPP_ASSERT(__ns >= 0, "invalid range specified");
+
+    clear();
+
     const size_t __n = static_cast<size_type>(__ns);
     if (__n)
     {
@@ -2899,7 +3081,7 @@
             __vdeallocate();
             __vallocate(__n);
         }
-        __construct_at_end(__first, __last);
+        __construct_at_end(__first, __last, __n);
     }
 }
 
@@ -2913,7 +3095,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(), this->size());
         swap(__v);
         std::__debug_db_invalidate_all(this);
     }
@@ -3025,6 +3207,14 @@
 >::type
 vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
 {
+  return __insert_with_sentinel(__position, __first, __last);
+}
+
+template <class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+typename vector<bool, _Allocator>::iterator
+vector<bool, _Allocator>::__insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last) {
     difference_type __off = __position - begin();
     iterator __p = __const_iterator_cast(__position);
     iterator __old_end = end();
@@ -3040,7 +3230,7 @@
         try
         {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __v.assign(__first, __last);
+            __v.__assign_with_sentinel(std::move(__first), std::move(__last));
             difference_type __old_size = static_cast<difference_type>(__old_end - begin());
             difference_type __old_p = __p - begin();
             reserve(__recommend(size() + __v.size()));
@@ -3070,7 +3260,15 @@
 >::type
 vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
 {
-    const difference_type __n_signed = std::distance(__first, __last);
+  return __insert_with_size(__position, __first, __last, std::distance(__first, __last));
+}
+
+template <class _Allocator>
+template <class _ForwardIterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+typename vector<bool, _Allocator>::iterator
+vector<bool, _Allocator>::__insert_with_size(const_iterator __position, _ForwardIterator __first, _Sentinel __last,
+                                             difference_type __n_signed) {
     _LIBCPP_ASSERT(__n_signed >= 0, "invalid range specified");
     const size_type __n = static_cast<size_type>(__n_signed);
     iterator __r;
@@ -3091,7 +3289,7 @@
         std::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
-    std::copy(__first, __last, __r);
+    std::__copy<_ClassicAlgPolicy>(__first, __last, __r);
     return __r;
 }
 
diff --git a/libcxx/include/version b/libcxx/include/version
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -150,7 +150,7 @@
 __cpp_lib_ranges_slide                                  202202L <ranges>
 __cpp_lib_ranges_starts_ends_with                       202106L <algorithm>
 __cpp_lib_ranges_to_container                           202202L <deque> <forward_list> <list>
-                                                                <map> <priority_queue> <queue>
+                                                                <map> <queue> <ranges>
                                                                 <set> <stack> <string>
                                                                 <unordered_map> <unordered_set> <vector>
 __cpp_lib_ranges_zip                                    202110L <ranges> <tuple> <utility>
@@ -419,7 +419,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
@@ -475,6 +475,7 @@
 #include <__iterator/permutable.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/permutable.h'}}
 #include <__iterator/prev.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/prev.h'}}
 #include <__iterator/projected.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/projected.h'}}
+#include <__iterator/ranges_iterator_traits.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/ranges_iterator_traits.h'}}
 #include <__iterator/readable_traits.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/readable_traits.h'}}
 #include <__iterator/reverse_access.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/reverse_access.h'}}
 #include <__iterator/reverse_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/reverse_iterator.h'}}
@@ -580,6 +581,7 @@
 #include <__ranges/as_rvalue_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/as_rvalue_view.h'}}
 #include <__ranges/common_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/common_view.h'}}
 #include <__ranges/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/concepts.h'}}
+#include <__ranges/container_compatible_range.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/container_compatible_range.h'}}
 #include <__ranges/copyable_box.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/copyable_box.h'}}
 #include <__ranges/counted.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/counted.h'}}
 #include <__ranges/dangling.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/dangling.h'}}
@@ -592,6 +594,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'}}
@@ -609,6 +612,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/libcxx/ranges/range.utility/range.utility.conv/to.internal_constraints.verify.cpp b/libcxx/test/libcxx/ranges/range.utility/range.utility.conv/to.internal_constraints.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/ranges/range.utility/range.utility.conv/to.internal_constraints.verify.cpp
@@ -0,0 +1,94 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// Test that the "mandates" requirements on the given container are checked correctly using `static_assert`.
+
+#include <ranges>
+#include <vector>
+
+template <bool HasDefaultCtr = true, bool HasSingleArgCtr = true,
+          bool HasInsert = true, bool HasInsertWithRightSignature = true,
+          bool HasPushBack = true, bool HasPushBackWithRightSignature = true>
+struct Container {
+  using value_type = int;
+
+  int* begin() const { return nullptr; }
+  int* end() const { return nullptr; }
+
+  Container()
+  requires HasDefaultCtr = default;
+
+  Container(int)
+  requires HasSingleArgCtr {
+  }
+
+  int* insert(int*, int)
+  requires (HasInsert && HasInsertWithRightSignature) {
+    return nullptr;
+  }
+
+  int* insert()
+  requires (HasInsert && !HasInsertWithRightSignature) {
+    return nullptr;
+  }
+
+  void push_back(int)
+  requires (HasPushBack && HasPushBackWithRightSignature) {
+  }
+
+  void push_back()
+  requires (HasPushBack && !HasPushBackWithRightSignature) {
+  }
+
+};
+
+void test() {
+  using R = std::vector<int>;
+  R in = {1, 2, 3};
+
+  // Case 4 -- default-construct (or construct from the extra arguments) and insert.
+  { // All constraints satisfied.
+    using C = Container<>;
+    (void)std::ranges::to<C>(in);
+    (void)std::ranges::to<C>(in, 1);
+    (void)std::ranges::to<C>(in, 1.0);
+  }
+
+  { // No default constructor.
+    using C = Container</*HasDefaultCtr=*/false>;
+    (void)std::ranges::to<C>(in); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}ranges::to: unable to convert to the given container type}}
+  }
+
+  { // No single-argument constructor.
+    using C = Container</*HasDefaultCtr=*/true, /*HasSingleArgCtr=*/false>;
+    (void)std::ranges::to<C>(in, 1); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}ranges::to: unable to convert to the given container type}}
+  }
+
+  { // No `insert` and no `push_back`.
+    using C = Container</*HasDefaultCtr=*/true, /*HasSingleArgCtr=*/true,
+                        /*HasInsert=*/false, /*HasInsertWithRightSignature=*/false,
+                        /*HasPushBack=*/false, /*HasPushBackWithRightSignature=*/false>;
+    (void)std::ranges::to<C>(in); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}ranges::to: unable to convert to the given container type}}
+  }
+
+  { // No `push_back`, `insert` has a wrong signature.
+    using C = Container</*HasDefaultCtr=*/true, /*HasSingleArgCtr=*/true,
+                        /*HasInsert=*/true, /*HasInsertWithRightSignature=*/false,
+                        /*HasPushBack=*/false, /*HasPushBackWithRightSignature=*/false>;
+    (void)std::ranges::to<C>(in); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}ranges::to: unable to convert to the given container type}}
+  }
+
+  { // No `insert`, `push_back` has a wrong signature.
+    using C = Container</*HasDefaultCtr=*/true, /*HasSingleArgCtr=*/true,
+                        /*HasInsert=*/false, /*HasInsertWithRightSignature=*/false,
+                        /*HasPushBack=*/true, /*HasPushBackWithRightSignature=*/false>;
+    (void)std::ranges::to<C>(in); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}ranges::to: unable to convert to the given container type}}
+  }
+}
diff --git a/libcxx/test/libcxx/ranges/range.utility/range.utility.conv/to.nodiscard.verify.cpp b/libcxx/test/libcxx/ranges/range.utility/range.utility.conv/to.nodiscard.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/ranges/range.utility/range.utility.conv/to.nodiscard.verify.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// Test the libc++ extension that `std::ranges::to` is marked as [[nodiscard]].
+
+#include <ranges>
+#include <vector>
+
+void test() {
+  using R = std::vector<int>;
+  R in = {1, 2, 3};
+  std::allocator<int> alloc;
+
+  std::ranges::to<R>(in); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::ranges::to<R>(in, alloc); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::ranges::to<std::vector>(in); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::ranges::to<std::vector>(in, alloc); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  in | std::ranges::to<R>(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  in | std::ranges::to<R>(alloc); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  in | std::ranges::to<std::vector>(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  in | std::ranges::to<std::vector>(alloc); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/libcxx/test/libcxx/ranges/range.utility/range.utility.conv/to.static_assert.verify.cpp b/libcxx/test/libcxx/ranges/range.utility/range.utility.conv/to.static_assert.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/ranges/range.utility/range.utility.conv/to.static_assert.verify.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile
+
+// Test that the "mandates" requirements on the given container are checked using `static_assert`.
+
+#include <ranges>
+#include <vector>
+
+void test() {
+  using R = std::vector<int>;
+  R in = {1, 2, 3};
+
+  (void)std::ranges::to<const R>(in); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}The target container cannot be const-qualified, please remove the const}}
+  (void)(in | std::ranges::to<const R>()); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}The target container cannot be const-qualified, please remove the const}}
+  (void)std::ranges::to<volatile R>(in); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}The target container cannot be volatile-qualified, please remove the volatile}}
+  (void)(in | std::ranges::to<volatile R>()); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}The target container cannot be volatile-qualified, please remove the volatile}}
+}
diff --git a/libcxx/test/std/containers/associative/from_range_associative_containers.h b/libcxx/test/std/containers/associative/from_range_associative_containers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/from_range_associative_containers.h
@@ -0,0 +1,301 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_FROM_RANGE_ASSOCIATIVE_CONTAINERS_H
+#define SUPPORT_FROM_RANGE_ASSOCIATIVE_CONTAINERS_H
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <ranges>
+#include <vector>
+#include <utility>
+
+#include "../from_range_helpers.h"
+#include "../test_compare.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "test_macros.h"
+
+template <class Container, class Range>
+concept HasFromRangeCtr = requires (Range&& range) {
+  Container(std::from_range, std::forward<Range>(range));
+  Container(std::from_range, std::forward<Range>(range), std::less<typename Container::key_type>());
+  Container(std::from_range, std::forward<Range>(range), std::less<typename Container::key_type>(),
+      std::allocator<typename Container::value_type>());
+};
+
+template <template <class...> class Container, class K, class V, class K2, class V2>
+constexpr bool test_map_constraints() {
+  using ValueType = std::pair<const K, V>;
+
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<Container<K, V>, InputRange<ValueType>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<Container<K, V>, InputRange<std::pair<const K2, V2>>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<Container<K, V>, InputRange<std::pair<const Empty, V>>>);
+  static_assert(!HasFromRangeCtr<Container<K, V>, InputRange<std::pair<const K, Empty>>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<Container<K, V>, InputRangeNotDerivedFromGeneric<ValueType>>);
+
+  return true;
+}
+
+template <template <class ...> class Container,
+          class K,
+          class V,
+          class Iter,
+          class Sent,
+          class Comp,
+          class Alloc,
+          class ValueType = std::pair<const K, V>>
+void test_associative_map_with_input(std::vector<ValueType>&& input) {
+  auto in = wrap_input<Iter, Sent>(input);
+
+  { // (range)
+    Container<K, V> c(std::from_range, in);
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+  }
+
+  { // (range, comp)
+    Comp comp;
+    Container<K, V, Comp> c(std::from_range, in, comp);
+
+    assert(c.key_comp() == comp);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+  }
+
+  { // (range, allocator)
+    Alloc alloc;
+    Container<K, V, std::less<K>, Alloc> c(std::from_range, in, alloc);
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+  }
+
+  { // (range, comp, allocator)
+    Comp comp;
+    Alloc alloc;
+    Container<K, V, Comp, Alloc> c(std::from_range, in, comp, alloc);
+
+    assert(c.key_comp() == comp);
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+  }
+}
+
+template <template <class ...> class Container,
+          class K,
+          class V,
+          class Iter,
+          class Sent,
+          class Comp,
+          class Alloc>
+void test_associative_map() {
+  auto test_with_input = &test_associative_map_with_input<Container, K, V, Iter, Sent, Comp, Alloc>;
+
+  // Normal input.
+  test_with_input({{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}});
+  // Empty input.
+  test_with_input({});
+  // Single-element input.
+  test_with_input({{1, 2}});
+}
+
+template <template <class ...> class Container>
+void test_associative_map_move_only() {
+  std::pair<const int, MoveOnly> input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  [[maybe_unused]] Container<int, MoveOnly> c(std::from_range, in);
+}
+
+template <template <class ...> class Container>
+void test_map_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using K = int;
+  using V = ThrowingCopy<3>;
+
+  V::throwing_enabled = false;
+  std::pair<const K, V> in[5] = {
+    {1, {}}, {2, {}}, {3, {}}, {4, {}}, {5, {}}
+  };
+  V::throwing_enabled = true;
+  V::reset();
+
+  try {
+    Container<K, V> c(std::from_range, in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(V::created_by_copying == 3);
+    assert(V::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class K, class V>
+void test_map_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using ValueType = std::pair<const K, V>;
+  ValueType in[] = {
+    ValueType{K{1}, V{1}}
+  };
+
+  try {
+    ThrowingAllocator<ValueType> alloc;
+
+    globalMemCounter.reset();
+    Container<K, V, test_less<K>, ThrowingAllocator<ValueType>> c(std::from_range, in, alloc);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <class Container, class Range>
+concept SetHasFromRangeCtr = requires (Range&& range) {
+  Container(std::from_range, std::forward<Range>(range));
+  Container(std::from_range, std::forward<Range>(range), std::less<typename Container::value_type>());
+  Container(std::from_range, std::forward<Range>(range), std::less<typename Container::value_type>(),
+      std::allocator<typename Container::value_type>());
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_set_constraints() {
+  // Input range with the same value type.
+  static_assert(SetHasFromRangeCtr<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(SetHasFromRangeCtr<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!SetHasFromRangeCtr<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!SetHasFromRangeCtr<Container<T>, InputRangeNotDerivedFromGeneric<T>>);
+
+  return true;
+}
+
+template <template <class ...> class Container,
+          class T,
+          class Iter,
+          class Sent,
+          class Comp,
+          class Alloc>
+void test_associative_set_with_input(std::vector<T>&& input) {
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    Container<T> c(std::from_range, in);
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+  }
+
+  { // (range, comp)
+    Comp comp;
+    Container<T, Comp> c(std::from_range, in, comp);
+
+    assert(c.key_comp() == comp);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+  }
+
+  { // (range, allocator)
+    Alloc alloc;
+    Container<T, std::less<T>, Alloc> c(std::from_range, in, alloc);
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+  }
+
+  { // (range, comp, allocator)
+    Comp comp;
+    Alloc alloc;
+    Container<T, Comp, Alloc> c(std::from_range, in, comp, alloc);
+
+    assert(c.key_comp() == comp);
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+  }
+}
+
+template <template <class ...> class Container,
+          class T,
+          class Iter,
+          class Sent,
+          class Comp,
+          class Alloc>
+void test_associative_set() {
+  auto test_with_input = &test_associative_set_with_input<Container, T, Iter, Sent, Comp, Alloc>;
+
+  // Normal input.
+  test_with_input({0, 5, 12, 7, -1, 8, 26});
+  // Empty input.
+  test_with_input({});
+  // Single-element input.
+  test_with_input({5});
+}
+
+template <template <class ...> class Container>
+void test_associative_set_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  [[maybe_unused]] Container<MoveOnly> c(std::from_range, in);
+}
+
+template <template <class ...> class Container>
+void test_set_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5] = {{1}, {2}, {3}, {4}, {5}};
+
+  try {
+    Container<T> c(std::from_range, in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_set_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {1, 2};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, test_less<T>, ThrowingAllocator<T>> c(std::from_range, in, alloc);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_FROM_RANGE_ASSOCIATIVE_CONTAINERS_H
diff --git a/libcxx/test/std/containers/associative/map/map.cons/deduct.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.cons/deduct.pass.cpp
@@ -24,8 +24,18 @@
 // template<class Key, class Allocator>
 // map(initializer_list<Key>, Allocator)
 //   -> map<Key, less<Key>, Allocator>;
+//
+// template<ranges::input_range R, class Compare = less<range-key-type<R>,
+//          class Allocator = allocator<range-to-alloc-type<R>>>
+//   map(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+//     -> map<range-key-type<R>, range-mapped-type<R>, Compare, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   map(from_range_t, R&&, Allocator)
+//     -> map<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>, Allocator>; // C++23
 
 #include <algorithm> // std::equal
+#include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <functional>
@@ -152,6 +162,35 @@
     ASSERT_SAME_TYPE(decltype(m2), std::map<int, int>);
     }
 
+#if TEST_STD_VER >= 23
+    {
+      using Range = std::array<P, 0>;
+      using Comp = std::greater<int>;
+      using DefaultComp = std::less<int>;
+      using Alloc = test_allocator<PC>;
+
+      { // (from_range, range)
+        std::map c(std::from_range, Range());
+        static_assert(std::is_same_v<decltype(c), std::map<int, long>>);
+      }
+
+      { // (from_range, range, comp)
+        std::map c(std::from_range, Range(), Comp());
+        static_assert(std::is_same_v<decltype(c), std::map<int, long, Comp>>);
+      }
+
+      { // (from_range, range, comp, alloc)
+        std::map c(std::from_range, Range(), Comp(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::map<int, long, Comp, Alloc>>);
+      }
+
+      { // (from_range, range, alloc)
+        std::map c(std::from_range, Range(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::map<int, long, DefaultComp, Alloc>>);
+      }
+    }
+#endif
+
     AssociativeContainerDeductionGuidesSfinaeAway<std::map, std::map<int, long>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/associative/map/map.cons/from_range.pass.cpp b/libcxx/test/std/containers/associative/map/map.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/map/map.cons/from_range.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <map>
+
+#include "../../from_range_associative_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   map(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   map(from_range_t, R&& rg, const Allocator& a))
+//     : map(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
+
+void test_duplicates() {
+  using T = std::pair<const int, char>;
+
+  std::array input = {
+    T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{3, 'b'}, T{3, 'c'}, T{2, 'b'}, T{4, 'a'}
+  };
+  std::array expected = {
+    T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{4, 'a'}
+  };
+  auto c = std::map<int, char>(std::from_range, input);
+  assert(std::ranges::is_permutation(expected, c));
+}
+
+int main(int, char**) {
+  using T = std::pair<const int, int>;
+  for_all_iterators_and_allocators<T>([]<class Iter, class Sent, class Alloc>() {
+    test_associative_map<std::map, int, int, Iter, Sent, test_less<int>, Alloc>();
+  });
+  test_associative_map_move_only<std::map>();
+  test_duplicates();
+
+  static_assert(test_map_constraints<std::map, int, int, double, double>());
+
+  test_map_exception_safety_throwing_copy<std::map>();
+  test_map_exception_safety_throwing_allocator<std::map, int, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/associative/map/map.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/associative/map/map.modifiers/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/map/map.modifiers/insert_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <map>
+
+// template<container-compatible-range<value_type> R>
+//   void insert_range(R&& rg); // C++23
+
+#include <map>
+
+#include "../../../insert_range_maps_sets.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  // Note: we want to use a pair with non-const elements for input (an assignable type is a lot more convenient) but
+  // have to use the exact `value_type` of the map (that is, `pair<const K, V>`) for the allocator.
+  using Pair = std::pair<int, char>;
+  using ConstPair = std::pair<const int, char>;
+  for_all_iterators_and_allocators<ConstPair, const Pair*>([]<class Iter, class Sent, class Alloc>() {
+    test_map_set_insert_range<std::map<int, char, test_less<int>, Alloc>, Pair, Iter, Sent>();
+  });
+
+  static_assert(test_map_constraints_insert_range<std::map, int, int, char, double>());
+
+  test_map_insert_range_move_only<std::map>();
+
+  test_map_insert_range_exception_safety_throwing_copy<std::map>();
+  test_assoc_map_insert_range_exception_safety_throwing_allocator<std::map, int, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.pass.cpp
@@ -24,8 +24,18 @@
 // template<class Key, class Allocator>
 // multimap(initializer_list<Key>, Allocator)
 //   -> multimap<Key, less<Key>, Allocator>;
+//
+// template<ranges::input_range R, class Compare = less<range-key-type<R>>,
+//           class Allocator = allocator<range-to-alloc-type<R>>>
+//   multimap(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+//     -> multimap<range-key-type<R>, range-mapped-type<R>, Compare, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   multimap(from_range_t, R&&, Allocator)
+//     -> multimap<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>, Allocator>; // C++23
 
 #include <algorithm> // std::equal
+#include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <functional>
@@ -152,6 +162,35 @@
     ASSERT_SAME_TYPE(decltype(m2), std::multimap<int, int>);
     }
 
+#if TEST_STD_VER >= 23
+    {
+      using Range = std::array<P, 0>;
+      using Comp = std::greater<int>;
+      using DefaultComp = std::less<int>;
+      using Alloc = test_allocator<PC>;
+
+      { // (from_range, range)
+        std::multimap c(std::from_range, Range());
+        static_assert(std::is_same_v<decltype(c), std::multimap<int, long>>);
+      }
+
+      { // (from_range, range, comp)
+        std::multimap c(std::from_range, Range(), Comp());
+        static_assert(std::is_same_v<decltype(c), std::multimap<int, long, Comp>>);
+      }
+
+      { // (from_range, range, comp, alloc)
+        std::multimap c(std::from_range, Range(), Comp(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::multimap<int, long, Comp, Alloc>>);
+      }
+
+      { // (from_range, range, alloc)
+        std::multimap c(std::from_range, Range(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::multimap<int, long, DefaultComp, Alloc>>);
+      }
+    }
+#endif
+
     AssociativeContainerDeductionGuidesSfinaeAway<std::multimap, std::multimap<int, long>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/from_range.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/from_range.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <map>
+
+#include "../../from_range_associative_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   multimap(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   multimap(from_range_t, R&& rg, const Allocator& a))
+//     : multimap(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
+
+void test_duplicates() {
+  using T = std::pair<const int, char>;
+  std::array input = {
+    T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{3, 'b'}, T{3, 'c'}, T{2, 'b'}, T{4, 'a'}
+  };
+  auto c = std::multimap<int, char>(std::from_range, input);
+  assert(std::ranges::is_permutation(input, c));
+}
+
+int main(int, char**) {
+  using T = std::pair<const int, int>;
+  for_all_iterators_and_allocators<T>([]<class Iter, class Sent, class Alloc>() {
+    test_associative_map<std::multimap, int, int, Iter, Sent, test_less<int>, Alloc>();
+  });
+  test_associative_map_move_only<std::multimap>();
+  test_duplicates();
+
+  static_assert(test_map_constraints<std::multimap, int, int, double, double>());
+
+  test_map_exception_safety_throwing_copy<std::multimap>();
+  test_map_exception_safety_throwing_allocator<std::multimap, int, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_range.pass.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <map>
+
+// template<container-compatible-range<value_type> R>
+//   void insert_range(R&& rg); // C++23
+
+#include <map>
+
+#include "../../../insert_range_maps_sets.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  // Note: we want to use a pair with non-const elements for input (an assignable type is a lot more convenient) but
+  // have to use the exact `value_type` of the map (that is, `pair<const K, V>`) for the allocator.
+  using Pair = std::pair<int, char>;
+  using ConstPair = std::pair<const int, char>;
+  for_all_iterators_and_allocators<ConstPair, const Pair*>([]<class Iter, class Sent, class Alloc>() {
+    test_map_set_insert_range<std::multimap<int, char, test_less<int>, Alloc>, Pair, Iter, Sent>(/*allow_duplicates=*/true);
+  });
+
+  static_assert(test_map_constraints_insert_range<std::multimap, int, int, char, double>());
+
+  test_map_insert_range_move_only<std::multimap>();
+
+  test_map_insert_range_exception_safety_throwing_copy<std::multimap>();
+  test_assoc_map_insert_range_exception_safety_throwing_allocator<std::multimap, int, int>();
+
+  return 0;
+}
+
diff --git a/libcxx/test/std/containers/associative/multiset/insert_range.pass.cpp b/libcxx/test/std/containers/associative/multiset/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/multiset/insert_range.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <set>
+
+// template<container-compatible-range<value_type> R>
+//   void insert_range(R&& rg); // C++23
+
+#include <set>
+
+#include "../../insert_range_maps_sets.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_map_set_insert_range<std::multiset<int, test_less<int>, Alloc>, int, Iter, Sent>(/*allow_duplicates=*/true);
+  });
+
+  static_assert(test_set_constraints_insert_range<std::multiset, int, double>());
+
+  test_set_insert_range_move_only<std::multiset>();
+
+  test_set_insert_range_exception_safety_throwing_copy<std::multiset>();
+  test_assoc_set_insert_range_exception_safety_throwing_allocator<std::multiset, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/deduct.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/deduct.pass.cpp
@@ -27,8 +27,18 @@
 // template<class Key, class Allocator>
 // multiset(initializer_list<Key>, Allocator)
 //   -> multiset<Key, less<Key>, Allocator>;
+//
+// template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
+//          class Allocator = allocator<ranges::range_value_t<R>>>
+//   multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+//     -> multiset<ranges::range_value_t<R>, Compare, Allocator>;
+//
+// template<ranges::input_range R, class Allocator>
+//   multiset(from_range_t, R&&, Allocator)
+//     -> multiset<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>;
 
 #include <algorithm> // std::equal
+#include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <functional>
@@ -187,6 +197,35 @@
     assert(s.size() == 2);
   }
 
+#if TEST_STD_VER >= 23
+    {
+      using Range = std::array<int, 0>;
+      using Comp = std::greater<int>;
+      using DefaultComp = std::less<int>;
+      using Alloc = test_allocator<int>;
+
+      { // (from_range, range)
+        std::multiset c(std::from_range, Range());
+        static_assert(std::is_same_v<decltype(c), std::multiset<int>>);
+      }
+
+      { // (from_range, range, comp)
+        std::multiset c(std::from_range, Range(), Comp());
+        static_assert(std::is_same_v<decltype(c), std::multiset<int, Comp>>);
+      }
+
+      { // (from_range, range, comp, alloc)
+        std::multiset c(std::from_range, Range(), Comp(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::multiset<int, Comp, Alloc>>);
+      }
+
+      { // (from_range, range, alloc)
+        std::multiset c(std::from_range, Range(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::multiset<int, DefaultComp, Alloc>>);
+      }
+    }
+#endif
+
   AssociativeContainerDeductionGuidesSfinaeAway<std::multiset, std::multiset<int>>();
 
   return 0;
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/from_range.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/from_range.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <algorithm>
+#include <array>
+#include <set>
+
+#include "../../from_range_associative_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   multiset(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   multiset(from_range_t, R&& rg, const Allocator& a))
+//     : multiset(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
+
+void test_duplicates() {
+  std::array input = {1, 2, 3, 3, 3, 4, 2, 1, 2};
+  auto c = std::multiset<int>(std::from_range, input);
+  assert(std::ranges::is_permutation(input, c));
+}
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_associative_set<std::multiset, int, Iter, Sent, test_less<int>, Alloc>();
+  });
+  test_associative_set_move_only<std::multiset>();
+  test_duplicates();
+
+  static_assert(test_set_constraints<std::multiset, int, double>());
+
+  test_set_exception_safety_throwing_copy<std::multiset>();
+  test_set_exception_safety_throwing_allocator<std::multiset, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/associative/set/insert_range.pass.cpp b/libcxx/test/std/containers/associative/set/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/set/insert_range.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <set>
+
+// template<container-compatible-range<value_type> R>
+//   void insert_range(R&& rg); // C++23
+
+#include <set>
+
+#include "../../insert_range_maps_sets.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_map_set_insert_range<std::set<int, test_less<int>, Alloc>, int, Iter, Sent>();
+  });
+
+  static_assert(test_set_constraints_insert_range<std::set, int, double>());
+
+  test_set_insert_range_move_only<std::set>();
+
+  test_set_insert_range_exception_safety_throwing_copy<std::set>();
+  test_assoc_set_insert_range_exception_safety_throwing_allocator<std::set, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/associative/set/set.cons/deduct.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/deduct.pass.cpp
@@ -27,8 +27,18 @@
 // template<class Key, class Allocator>
 // set(initializer_list<Key>, Allocator)
 //   -> set<Key, less<Key>, Allocator>;
+//
+// template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
+//          class Allocator = allocator<ranges::range_value_t<R>>>
+//   set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+//     -> set<ranges::range_value_t<R>, Compare, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   set(from_range_t, R&&, Allocator)
+//     -> set<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>; // C++23
 
 #include <algorithm> // std::equal
+#include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <functional>
@@ -185,6 +195,35 @@
     assert(s.size() == 2);
   }
 
+#if TEST_STD_VER >= 23
+    {
+      using Range = std::array<int, 0>;
+      using Comp = std::greater<int>;
+      using DefaultComp = std::less<int>;
+      using Alloc = test_allocator<int>;
+
+      { // (from_range, range)
+        std::set c(std::from_range, Range());
+        static_assert(std::is_same_v<decltype(c), std::set<int>>);
+      }
+
+      { // (from_range, range, comp)
+        std::set c(std::from_range, Range(), Comp());
+        static_assert(std::is_same_v<decltype(c), std::set<int, Comp>>);
+      }
+
+      { // (from_range, range, comp, alloc)
+        std::set c(std::from_range, Range(), Comp(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::set<int, Comp, Alloc>>);
+      }
+
+      { // (from_range, range, alloc)
+        std::set c(std::from_range, Range(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::set<int, DefaultComp, Alloc>>);
+      }
+    }
+#endif
+
   AssociativeContainerDeductionGuidesSfinaeAway<std::set, std::set<int>>();
 
   return 0;
diff --git a/libcxx/test/std/containers/associative/set/set.cons/from_range.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/set/set.cons/from_range.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <set>
+
+#include "../../from_range_associative_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   set(from_range_t, R&& rg, const Allocator& a))
+//     : set(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
+
+void test_duplicates() {
+  using T = KeyValue;
+
+  std::array input = {
+    T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{3, 'b'}, T{3, 'c'}, T{2, 'b'}, T{4, 'a'}
+  };
+  std::array expected = {
+    T{1, 'a'}, T{2, 'b'}, T{3, 'c'}, T{4, 'a'}
+  };
+  auto c = std::set<T>(std::from_range, input);
+  assert(std::ranges::is_permutation(expected, c));
+}
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_associative_set<std::set, int, Iter, Sent, test_less<int>, Alloc>();
+  });
+  test_associative_set_move_only<std::set>();
+  test_duplicates();
+
+  static_assert(test_set_constraints<std::set, int, double>());
+
+  test_set_exception_safety_throwing_copy<std::set>();
+  test_set_exception_safety_throwing_allocator<std::set, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/from_range_container_adaptors.h b/libcxx/test/std/containers/container.adaptors/from_range_container_adaptors.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/from_range_container_adaptors.h
@@ -0,0 +1,229 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_FROM_RANGE_CONTAINER_ADAPTORS_H
+#define SUPPORT_FROM_RANGE_CONTAINER_ADAPTORS_H
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <queue>
+#include <ranges>
+#include <utility>
+#include <vector>
+
+#include "../from_range_helpers.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "test_macros.h"
+#include "unwrap_container_adaptor.h"
+
+template <class Container, class Range>
+concept HasFromRangeCtr = requires (Range&& range) {
+  Container(std::from_range, std::forward<Range>(range));
+  Container(std::from_range, std::forward<Range>(range), std::allocator<typename Container::value_type>());
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints() {
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <template <class ...> class Adaptor,
+          template <class ...> class UnderlyingContainer,
+          class T,
+          class Iter,
+          class Sent,
+          class Alloc>
+constexpr void test_container_adaptor_with_input(std::vector<T>&& input) {
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    Adaptor<T> adaptor(std::from_range, in);
+    UnwrapAdaptor<Adaptor<T>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+    LIBCPP_ASSERT(c.__invariants());
+  }
+
+  { // (range, allocator)
+    using C = UnderlyingContainer<T, Alloc>;
+    Alloc alloc;
+    Adaptor<T, C> adaptor(std::from_range, in, alloc);
+    UnwrapAdaptor<Adaptor<T, C>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+    LIBCPP_ASSERT(c.__invariants());
+  }
+}
+
+template <template <class ...> class UnderlyingContainer,
+          class T,
+          class Iter,
+          class Sent,
+          class Comp,
+          class Alloc>
+constexpr void test_priority_queue_with_input(std::vector<T>&& input) {
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    std::priority_queue<T> adaptor(std::from_range, in);
+    UnwrapAdaptor<std::priority_queue<T>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    LIBCPP_ASSERT(c.__invariants());
+  }
+
+  { // (range, comp)
+    using C = UnderlyingContainer<T>;
+    Comp comp;
+
+    std::priority_queue<T, C, Comp> adaptor(std::from_range, in, comp);
+    UnwrapAdaptor<std::priority_queue<T, C, Comp>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    LIBCPP_ASSERT(c.__invariants());
+    assert(unwrap_adaptor.get_comparator() == comp);
+  }
+
+  { // (range, allocator)
+    using C = UnderlyingContainer<T, Alloc>;
+    Alloc alloc;
+
+    std::priority_queue<T, C> adaptor(std::from_range, in, alloc);
+    UnwrapAdaptor<std::priority_queue<T, C>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    LIBCPP_ASSERT(c.__invariants());
+  }
+
+  { // (range, comp, alloc)
+    using C = UnderlyingContainer<T, Alloc>;
+    Comp comp;
+    Alloc alloc;
+
+    std::priority_queue<T, C, Comp> adaptor(std::from_range, in, comp, alloc);
+    UnwrapAdaptor<std::priority_queue<T, C, Comp>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    LIBCPP_ASSERT(c.__invariants());
+    assert(unwrap_adaptor.get_comparator() == comp);
+  }
+}
+
+template <template <class ...> class Adaptor,
+          template <class ...> class UnderlyingContainer,
+          class T,
+          class Iter,
+          class Sent,
+          class Alloc>
+constexpr void test_container_adaptor() {
+  auto test_with_input = &test_container_adaptor_with_input<Adaptor, UnderlyingContainer, T, Iter, Sent, Alloc>;
+
+  // Normal input.
+  test_with_input({0, 5, 12, 7, -1, 8, 26});
+  // Empty input.
+  test_with_input({});
+  // Single-element input.
+  test_with_input({5});
+}
+
+template <template <class ...> class UnderlyingContainer,
+          class T,
+          class Iter,
+          class Sent,
+          class Comp,
+          class Alloc>
+constexpr void test_priority_queue() {
+  auto test_with_input = &test_priority_queue_with_input<UnderlyingContainer, T, Iter, Sent, Comp, Alloc>;
+
+  // Normal input.
+  test_with_input({0, 5, 12, 7, -1, 8, 26});
+  // Empty input.
+  test_with_input({});
+  // Single-element input.
+  test_with_input({5});
+}
+
+template <template <class ...> class Container>
+constexpr void test_container_adaptor_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  [[maybe_unused]] Container<MoveOnly> c(std::from_range, in);
+}
+
+template <template <class ...> class Adaptor>
+void test_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Adaptor<T, std::vector<T>> c(std::from_range, in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Adaptor, class T>
+void test_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    using C = std::vector<T, ThrowingAllocator<T>>;
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Adaptor<T, C> c(std::from_range, in, alloc);
+    assert(false); // The constructor call should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_FROM_RANGE_CONTAINER_ADAPTORS_H
diff --git a/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
@@ -22,14 +22,26 @@
 // template<class Compare, class Container, class Allocator>
 // priority_queue(Compare, Container, Allocator)
 //     -> priority_queue<typename Container::value_type, Container, Compare>;
+//
+// template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
+//   priority_queue(from_range_t, R&&, Compare = Compare())
+//     -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>>, Compare>; // C++23
+//
+// template<ranges::input_range R, class Compare, class Allocator>
+//   priority_queue(from_range_t, R&&, Compare, Allocator)
+//     -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>,
+//                         Compare>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   priority_queue(from_range_t, R&&, Allocator)
+//     -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>>; // C++23
 
-
-#include <queue>
-#include <vector>
-#include <iterator>
 #include <cassert>
-#include <cstddef>
 #include <climits> // INT_MAX
+#include <cstddef>
+#include <iterator>
+#include <queue>
+#include <vector>
 
 #include "deduction_guides_sfinae_checks.h"
 #include "test_macros.h"
@@ -238,6 +250,28 @@
         std::priority_queue pri(a, a+2, Comp(), std::move(cont), ConvertibleToAlloc(2));
         static_assert(std::is_same_v<decltype(pri), std::priority_queue<T, Cont, Comp>>);
         }
+
+#if TEST_STD_VER >= 23
+        { // (from_range, range)
+          std::priority_queue c(std::from_range, Cont());
+          static_assert(std::is_same_v<decltype(c), std::priority_queue<T>>);
+        }
+
+        { // (from_range, range, compare)
+          std::priority_queue c(std::from_range, Cont(), Comp());
+          static_assert(std::is_same_v<decltype(c), std::priority_queue<T, std::vector<T>, Comp>>);
+        }
+
+        { // (from_range, range, compare, alloc)
+          std::priority_queue c(std::from_range, Cont(), Comp(), Alloc(2));
+          static_assert(std::is_same_v<decltype(c), std::priority_queue<T, std::vector<T, Alloc>, Comp>>);
+        }
+
+        { // (from_range, range, alloc)
+          std::priority_queue c(std::from_range, Cont(), Alloc(2));
+          static_assert(std::is_same_v<decltype(c), std::priority_queue<T, std::vector<T, Alloc>>>);
+        }
+#endif // TEST_STD_VER >= 23
     }
 
     // Deduction guides should be SFINAE'd away when given:
@@ -354,6 +388,39 @@
         static_assert(SFINAEs_away<std::priority_queue, AllocAsComp, Cont>);
         // Cannot deduce from (comp, ALLOC_as_cont)
         static_assert(SFINAEs_away<std::priority_queue, Comp, AllocAsCont>);
+
+#if TEST_STD_VER >= 23
+        using Range = RangeT<int>;
+        using BadRange = BadRangeT<int>;
+
+        // (from_range, range)
+        //
+        // Cannot deduce from (from_range, BAD_range)
+        static_assert(SFINAEs_away<std::priority_queue, BadRange>);
+
+        // (from_range, range, compare)
+        //
+        // Cannot deduce from (from_range, BAD_range, compare)
+        static_assert(SFINAEs_away<std::priority_queue, BadRange, Comp>);
+
+        // (from_range, range, compare, alloc)
+        //
+        // Cannot deduce from (from_range, BAD_range, compare, alloc)
+        static_assert(SFINAEs_away<std::priority_queue, BadRange, Comp, Alloc>);
+        // Cannot deduce from (from_range, range, compare, BAD_alloc)
+        static_assert(SFINAEs_away<std::priority_queue, Range, Comp, BadAlloc>);
+        // Cannot deduce from (from_range, range, compare, DIFFERENT_alloc)
+        static_assert(SFINAEs_away<std::priority_queue, Range, Comp, DiffAlloc>);
+
+        // (from_range, range, alloc)
+        //
+        // Cannot deduce from (from_range, BAD_range, alloc)
+        static_assert(SFINAEs_away<std::priority_queue, BadRange, Alloc>);
+        // Cannot deduce from (from_range, range, BAD_alloc)
+        static_assert(SFINAEs_away<std::priority_queue, Range, BadAlloc>);
+        // Cannot deduce from (from_range, range, DIFFERENT_alloc)
+        static_assert(SFINAEs_away<std::priority_queue, Range, DiffAlloc>);
+#endif // TEST_STD_VER >= 23
     }
 
     return 0;
diff --git a/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/from_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/from_range.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <queue>
+
+#include "../../from_range_container_adaptors.h"
+#include "../../../test_compare.h"
+#include "test_macros.h"
+
+// template <container-compatible-range<T> R>
+//   priority_queue(from_range_t, R&& rg, const Compare& x = Compare()); // since C++23
+// template <container-compatible-range<T> R, class Alloc>
+//   priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&); // since C++23
+// template <container-compatible-range<T> R, class Alloc>
+//   priority_queue(from_range_t, R&& rg, const Alloc&); // since C++23
+
+template <class Range>
+concept PriorityQueueHasFromRangeCtr = requires (Range&& range) {
+  std::priority_queue<int>(std::from_range, std::forward<Range>(range));
+  std::priority_queue<int>(std::from_range, std::forward<Range>(range), std::less<int>());
+  std::priority_queue<int>(std::from_range, std::forward<Range>(range), std::less<int>(), std::allocator<int>());
+  std::priority_queue<int>(std::from_range, std::forward<Range>(range), std::allocator<int>());
+};
+
+constexpr bool test_constraints_priority_queue() {
+  // Input range with the same value type.
+  static_assert(PriorityQueueHasFromRangeCtr<InputRange<int>>);
+  // Input range with a convertible value type.
+  static_assert(PriorityQueueHasFromRangeCtr<InputRange<double>>);
+  // Input range with a non-convertible value type.
+  static_assert(!PriorityQueueHasFromRangeCtr<InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!PriorityQueueHasFromRangeCtr<InputRangeNotDerivedFrom>);
+  static_assert(!PriorityQueueHasFromRangeCtr<InputRangeNotIndirectlyReadable>);
+  static_assert(!PriorityQueueHasFromRangeCtr<InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_priority_queue<std::vector, int, Iter, Sent, test_less<int>, Alloc>();
+  });
+  test_container_adaptor_move_only<std::priority_queue>();
+
+  static_assert(test_constraints_priority_queue());
+
+  test_exception_safety_throwing_copy<std::priority_queue>();
+  test_exception_safety_throwing_allocator<std::priority_queue, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_range.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   void push_range(R&& rg); // C++23
+
+#include <queue>
+
+#include "../../push_range_container_adaptors.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_push_range<std::priority_queue<int, std::vector<int, Alloc>>, Iter, Sent>(/*is_result_heapified=*/true);
+  });
+  test_push_range_move_only<std::priority_queue>();
+  test_push_range_inserter_choice<std::priority_queue, int>(/*is_result_heapified=*/true);
+
+  static_assert(test_constraints_push_range<std::priority_queue, int, double>());
+
+  test_push_range_exception_safety_throwing_copy<std::priority_queue>();
+  test_push_range_exception_safety_throwing_allocator<std::priority_queue, std::vector, int>();
+
+  return 0;
+}
+
diff --git a/libcxx/test/std/containers/container.adaptors/push_range_container_adaptors.h b/libcxx/test/std/containers/container.adaptors/push_range_container_adaptors.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/push_range_container_adaptors.h
@@ -0,0 +1,299 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_PUSH_RANGE_CONTAINER_ADAPTORS_H
+#define SUPPORT_PUSH_RANGE_CONTAINER_ADAPTORS_H
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <cstddef>
+#include <initializer_list>
+#include <ranges>
+#include <type_traits>
+#include <vector>
+
+#include "../from_range_helpers.h"
+#include "../insert_range_helpers.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "unwrap_container_adaptor.h"
+
+template <class Container, class Range>
+concept HasPushRange = requires (Container& c, Range&& range) {
+  c.push_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_push_range() {
+  // Input range with the same value type.
+  static_assert(HasPushRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasPushRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasPushRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasPushRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasPushRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasPushRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+// Empty container.
+
+template <class T>
+TestCase<T> constexpr EmptyContainer_EmptyRange {
+  .initial = {}, .input = {}, .expected = {}
+};
+
+template <class T> constexpr TestCase<T> EmptyContainer_OneElementRange {
+  .initial = {}, .input = {5}, .expected = {5}
+};
+
+template <class T> constexpr TestCase<T> EmptyContainer_MidRange {
+  .initial = {}, .input = {5, 3, 1, 7, 9}, .expected = {5, 3, 1, 7, 9}
+};
+
+// One-element container.
+
+template <class T> constexpr TestCase<T> OneElementContainer_EmptyRange {
+  .initial = {3}, .input = {}, .expected = {3}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_OneElementRange {
+  .initial = {3}, .input = {-5}, .expected = {3, -5}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_MidRange {
+  .initial = {3}, .input = {-5, -3, -1, -7, -9}, .expected = {3, -5, -3, -1, -7, -9}
+};
+
+// Full container.
+
+template <class T> constexpr TestCase<T> FullContainer_EmptyRange {
+  .initial = {11, 29, 35, 14, 84}, .input = {}, .expected = {11, 29, 35, 14, 84}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_OneElementRange {
+  .initial = {11, 29, 35, 14, 84}, .input = {-5}, .expected = {11, 29, 35, 14, 84, -5}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_MidRange {
+  .initial = {11, 29, 35, 14, 84},
+  .input = {-5, -3, -1, -7, -9},
+  .expected = {11, 29, 35, 14, 84, -5, -3, -1, -7, -9}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_LongRange {
+  .initial = {11, 29, 35, 14, 84},
+  .input = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
+  .expected = {
+      11, 29, 35, 14, 84, -5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48
+  }
+};
+
+// Container adaptors tests.
+
+template <class Adaptor, class Iter, class Sent>
+constexpr void test_push_range(bool is_result_heapified = false) {
+  using T = typename Adaptor::value_type;
+
+  auto test = [&](auto& test_case) {
+    Adaptor adaptor(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+
+    adaptor.push_range(in);
+    UnwrapAdaptor<Adaptor> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    if (is_result_heapified) {
+      assert(std::ranges::is_heap(c));
+      return std::ranges::is_permutation(c, test_case.expected);
+    } else {
+      return std::ranges::equal(c, test_case.expected);
+    }
+  };
+
+  { // Empty container.
+    // empty_c.push_range(empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.push_range(one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.push_range(mid_range)
+    assert(test(EmptyContainer_MidRange<T>));
+  }
+
+  { // One-element container.
+    // one_element_c.push_range(empty_range)
+    assert(test(OneElementContainer_EmptyRange<T>));
+    // one_element_c.push_range(one_element_range)
+    assert(test(OneElementContainer_OneElementRange<T>));
+    // one_element_c.push_range(mid_range)
+    assert(test(OneElementContainer_MidRange<T>));
+  }
+
+  { // Full container.
+    // full_container.push_range(empty_range)
+    assert(test(FullContainer_EmptyRange<T>));
+    // full_container.push_range(one_element_range)
+    assert(test(FullContainer_OneElementRange<T>));
+    // full_container.push_range(mid_range)
+    assert(test(FullContainer_MidRange<T>));
+    // full_container.push_range(long_range)
+    assert(test(FullContainer_LongRange<T>));
+  }
+}
+
+// Move-only types.
+
+template <template <class ...> class Container>
+constexpr void test_push_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.push_range(in);
+}
+
+// Check that `append_range` is preferred if available and `push_back` is used as a fallback.
+
+enum class InserterChoice {
+  Invalid,
+  PushBack,
+  AppendRange
+};
+
+template <class T, InserterChoice Inserter>
+struct Container {
+  InserterChoice inserter_choice = InserterChoice::Invalid;
+
+  using value_type = T;
+  using iterator = T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using size_type = std::size_t;
+
+  static constexpr int Capacity = 8;
+  int size_ = 0;
+  value_type buffer_[Capacity] = {};
+
+  iterator begin() { return buffer_; }
+  iterator end() { return buffer_ + size_; }
+  size_type size() const { return size_; }
+
+  template <class U>
+  void push_back(U val)
+  requires (Inserter >= InserterChoice::PushBack) {
+    inserter_choice = InserterChoice::PushBack;
+    buffer_[size_] = val;
+    ++size_;
+  }
+
+  template <std::ranges::input_range Range>
+  void append_range(Range&& range)
+  requires (Inserter >= InserterChoice::AppendRange) {
+    assert(size() + std::ranges::distance(range) <= Capacity);
+
+    inserter_choice = InserterChoice::AppendRange;
+
+    for (auto&& e : range) {
+      buffer_[size_] = e;
+      ++size_;
+    }
+  }
+
+  friend bool operator==(const Container&, const Container&) = default;
+};
+
+template <template <class ...> class AdaptorT, class T>
+void test_push_range_inserter_choice(bool is_result_heapified = false) {
+  { // `append_range` is preferred if available.
+    using BaseContainer = Container<T, InserterChoice::AppendRange>;
+    using Adaptor = AdaptorT<T, BaseContainer>;
+    T in[] = {1, 2, 3, 4, 5};
+
+    Adaptor adaptor;
+    adaptor.push_range(in);
+
+    UnwrapAdaptor<Adaptor> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+    assert(c.inserter_choice == InserterChoice::AppendRange);
+    if (is_result_heapified) {
+      assert(std::ranges::is_heap(c));
+      assert(std::ranges::is_permutation(c, in));
+    } else {
+      assert(std::ranges::equal(c, in));
+    }
+  }
+
+  { // `push_back` is used as a fallback (via `back_inserter`).
+    using BaseContainer = Container<T, InserterChoice::PushBack>;
+    using Adaptor = AdaptorT<T, BaseContainer>;
+    T in[] = {1, 2, 3, 4, 5};
+
+    Adaptor adaptor;
+    adaptor.push_range(in);
+
+    UnwrapAdaptor<Adaptor> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+    assert(c.inserter_choice == InserterChoice::PushBack);
+    if (is_result_heapified) {
+      assert(std::ranges::is_heap(c));
+      assert(std::ranges::is_permutation(c, in));
+    } else {
+      assert(std::ranges::equal(c, in));
+    }
+  }
+}
+
+// Exception safety.
+
+template <template <class ...> class Container>
+void test_push_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.push_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Adaptor, template <class ...> class BaseContainer, class T>
+void test_push_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    globalMemCounter.reset();
+    Adaptor<T, BaseContainer<T, ThrowingAllocator<T>>> c;
+    c.push_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_PUSH_RANGE_CONTAINER_ADAPTORS_H
diff --git a/libcxx/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
@@ -14,7 +14,13 @@
 //
 // template<class Container, class Allocator>
 //   queue(Container, Allocator) -> queue<typename Container::value_type, Container>;
-
+//
+// template<ranges::input_range R>
+//   queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>; // since C++23
+//
+// template<ranges::input_range R, class Allocator>
+//     queue(from_range_t, R&&, Allocator)
+//       -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
 
 #include <array>
 #include <queue>
@@ -134,29 +140,7 @@
         }
     }
 
-    // Deduction guides should be SFINAE'd away when given:
-    // - a "bad" allocator (that is, a type not qualifying as an allocator);
-    // - an allocator instead of a container;
-    // - an allocator and a container that uses a different allocator.
-    {
-        using Cont = std::list<int>;
-        using Alloc = std::allocator<int>;
-        using DiffAlloc = test_allocator<int>;
-        using Iter = int*;
-
-        struct NotIter{};
-        struct NotAlloc {};
-
-        static_assert(SFINAEs_away<std::queue, Alloc, NotAlloc>);
-        static_assert(SFINAEs_away<std::queue, Cont, NotAlloc>);
-        static_assert(SFINAEs_away<std::queue, Cont, DiffAlloc>);
-        static_assert(SFINAEs_away<std::queue, Iter, NotIter>);
-#if TEST_STD_VER > 20
-        static_assert(SFINAEs_away<std::queue, Iter, NotIter, Alloc>);
-        static_assert(SFINAEs_away<std::queue, Iter, Iter, NotAlloc>);
-#endif
-    }
-#if TEST_STD_VER > 20
+#if TEST_STD_VER >= 23
     {
         typedef short T;
         typedef test_allocator<T> Alloc;
@@ -170,6 +154,22 @@
         static_assert(std::is_same_v<decltype(q), std::queue<T, std::deque<T, Alloc>>>);
         }
     }
+
+    {
+      {
+        std::queue c(std::from_range, std::array<int, 0>());
+        static_assert(std::is_same_v<decltype(c), std::queue<int>>);
+      }
+
+      {
+        using Alloc = test_allocator<int>;
+        std::queue c(std::from_range, std::array<int, 0>(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::queue<int, std::deque<int, Alloc>>>);
+      }
+    }
 #endif
+
+    ContainerAdaptorDeductionGuidesSfinaeAway<std::queue, std::queue<int>>();
+
     return 0;
 }
diff --git a/libcxx/test/std/containers/container.adaptors/queue/queue.cons/from_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/queue/queue.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/queue/queue.cons/from_range.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <queue>
+
+#include "../../from_range_container_adaptors.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R> queue(from_range_t, R&& rg); // since C++23
+// template<container-compatible-range<T> R, class Alloc>
+//   queue(from_range_t, R&& rg, const Alloc&); // since C++23
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_container_adaptor<std::queue, std::deque, int, Iter, Sent, Alloc>();
+  });
+  test_container_adaptor_move_only<std::queue>();
+
+  static_assert(test_constraints<std::queue, int, double>());
+
+  test_exception_safety_throwing_copy<std::queue>();
+  test_exception_safety_throwing_allocator<std::queue, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/queue/queue.defn/push_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/queue/queue.defn/push_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/queue/queue.defn/push_range.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   void push_range(R&& rg); // C++23
+
+#include <queue>
+
+#include "../../push_range_container_adaptors.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_push_range<std::queue<int, std::deque<int, Alloc>>, Iter, Sent>();
+  });
+  test_push_range_move_only<std::queue>();
+  test_push_range_inserter_choice<std::queue, int>();
+
+  static_assert(test_constraints_push_range<std::queue, int, double>());
+
+  test_push_range_exception_safety_throwing_copy<std::queue>();
+  test_push_range_exception_safety_throwing_allocator<std::queue, std::deque, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
@@ -14,7 +14,13 @@
 //
 // template<class Container, class Allocator>
 //   stack(Container, Allocator) -> stack<typename Container::value_type, Container>;
-
+//
+// template<ranges::input_range R>
+//   stack(from_range_t, R&&) -> stack<ranges::range_value_t<R>>; // since C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   stack(from_range_t, R&&, Allocator)
+//     -> stack<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
 
 #include <array>
 #include <stack>
@@ -138,30 +144,7 @@
         }
     }
 
-    // Deduction guides should be SFINAE'd away when given:
-    // - a "bad" allocator (that is, a type not qualifying as an allocator);
-    // - an allocator instead of a container;
-    // - an allocator and a container that uses a different allocator.
-    {
-        using Cont = std::list<int>;
-        using Alloc = std::allocator<int>;
-        using DiffAlloc = test_allocator<int>;
-        using Iter = int;
-
-        struct NotIter {};
-        struct NotAlloc {};
-
-        static_assert(SFINAEs_away<std::stack, Alloc, Alloc>);
-        static_assert(SFINAEs_away<std::stack, Cont, NotAlloc>);
-        static_assert(SFINAEs_away<std::stack, Cont, DiffAlloc>);
-        static_assert(SFINAEs_away<std::stack, Iter, NotIter>);
-#if TEST_STD_VER > 20
-        static_assert(SFINAEs_away<std::stack, Iter, NotIter, Alloc>);
-        static_assert(SFINAEs_away<std::stack, Iter, Iter, NotAlloc>);
-#endif
-    }
-
-#if TEST_STD_VER > 20
+#if TEST_STD_VER >= 23
     {
         typedef short T;
         typedef test_allocator<T> Alloc;
@@ -175,7 +158,22 @@
         static_assert(std::is_same_v<decltype(s), std::stack<T, std::deque<T, Alloc>>>);
         }
     }
+
+    {
+      {
+        std::stack c(std::from_range, std::array<int, 0>());
+        static_assert(std::is_same_v<decltype(c), std::stack<int>>);
+      }
+
+      {
+        using Alloc = test_allocator<int>;
+        std::stack c(std::from_range, std::array<int, 0>(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::stack<int, std::deque<int, Alloc>>>);
+      }
+    }
 #endif
 
+    ContainerAdaptorDeductionGuidesSfinaeAway<std::stack, std::stack<int>>();
+
     return 0;
 }
diff --git a/libcxx/test/std/containers/container.adaptors/stack/stack.cons/from_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/stack/stack.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/stack/stack.cons/from_range.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <stack>
+
+#include "../../from_range_container_adaptors.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R> stack(from_range_t, R&& rg); // since C++23
+// template<container-compatible-range<T> R, class Alloc>
+//   stack(from_range_t, R&& rg, const Alloc&); // since C++23
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_container_adaptor<std::stack, std::deque, int, Iter, Sent, Alloc>();
+  });
+  test_container_adaptor_move_only<std::stack>();
+
+  static_assert(test_constraints<std::stack, int, double>());
+
+  test_exception_safety_throwing_copy<std::stack>();
+  test_exception_safety_throwing_allocator<std::stack, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/container.adaptors/stack/stack.defn/push_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/stack/stack.defn/push_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/container.adaptors/stack/stack.defn/push_range.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   void push_range(R&& rg); // C++23
+
+#include <stack>
+
+#include "../../push_range_container_adaptors.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_push_range<std::stack<int, std::deque<int, Alloc>>, Iter, Sent>();
+  });
+  test_push_range_move_only<std::stack>();
+  test_push_range_inserter_choice<std::stack, int>();
+
+  static_assert(test_constraints_push_range<std::stack, int, double>());
+
+  test_push_range_exception_safety_throwing_copy<std::stack>();
+  test_push_range_exception_safety_throwing_allocator<std::stack, std::deque, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/from_range_helpers.h b/libcxx/test/std/containers/from_range_helpers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/from_range_helpers.h
@@ -0,0 +1,148 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_FROM_RANGE_HELPERS_H
+#define SUPPORT_FROM_RANGE_HELPERS_H
+
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+
+struct Empty {};
+
+template <class T>
+struct InputRange {
+  cpp20_input_iterator<T*> begin();
+  sentinel_wrapper<cpp20_input_iterator<T*>> end();
+};
+
+template <class Iter, class Sent, std::ranges::input_range Range>
+constexpr auto wrap_input(Range&& input) {
+  auto b = Iter(std::ranges::begin(input));
+  auto e = Sent(Iter(std::ranges::end(input)));
+  return std::ranges::subrange(std::move(b), std::move(e));
+}
+
+template <class Iter, class Sent, class T>
+constexpr auto wrap_input(std::vector<T>& input) {
+  auto b = Iter(input.data());
+  auto e = Sent(Iter(input.data() + input.size()));
+  return std::ranges::subrange(std::move(b), std::move(e));
+}
+
+struct KeyValue {
+  int key; // Only the key is considered for equality comparison.
+  char value; // Allows distinguishing equivalent instances.
+
+  bool operator<(const KeyValue& other) const { return key < other.key; }
+  bool operator==(const KeyValue& other) const { return key == other.key; }
+};
+
+template <>
+struct std::hash<KeyValue> {
+  std::size_t operator()(const KeyValue& kv) const {
+    return kv.key;
+  }
+};
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+template <int N>
+struct ThrowingCopy {
+  static bool throwing_enabled;
+  static int created_by_copying;
+  static int destroyed;
+  int x = 0; // Allows distinguishing between different instances.
+
+  ThrowingCopy() = default;
+  ThrowingCopy(int value) : x(value) {}
+  ~ThrowingCopy() {
+    ++destroyed;
+  }
+
+  ThrowingCopy(const ThrowingCopy& other) : x(other.x) {
+    ++created_by_copying;
+    if (throwing_enabled && created_by_copying == N) {
+      throw -1;
+    }
+  }
+
+  friend auto operator<=>(const ThrowingCopy&, const ThrowingCopy&) = default;
+
+  static void reset() {
+    created_by_copying = destroyed = 0;
+  }
+};
+
+template <int N>
+struct std::hash<ThrowingCopy<N>> {
+  std::size_t operator()(const ThrowingCopy<N>& value) const {
+    return value.x;
+  }
+};
+
+template <int N>
+bool ThrowingCopy<N>::throwing_enabled = true;
+template <int N>
+int ThrowingCopy<N>::created_by_copying = 0;
+template <int N>
+int ThrowingCopy<N>::destroyed = 0;
+
+template <class T>
+struct ThrowingAllocator {
+  using value_type = T;
+  using char_type = T;
+  using is_always_equal = std::false_type;
+
+  ThrowingAllocator() = default;
+
+  template <class U>
+  ThrowingAllocator(const ThrowingAllocator<U>&) {}
+
+  T* allocate(std::size_t) { throw 1; }
+  void deallocate(T*, std::size_t) {}
+
+  template <class U>
+  friend bool operator==(const ThrowingAllocator&, const ThrowingAllocator<U>&) {
+    return true;
+  }
+};
+#endif
+
+template <class T, class Func>
+constexpr void for_all_iterators_and_allocators(Func f) {
+  using Iterators = types::type_list<
+    cpp20_input_iterator<T*>,
+    forward_iterator<T*>,
+    bidirectional_iterator<T*>,
+    random_access_iterator<T*>,
+    contiguous_iterator<T*>,
+    T*
+  >;
+
+  types::for_each(Iterators{}, [=]<class Iter>() {
+    f.template operator()<Iter, sentinel_wrapper<Iter>, std::allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, test_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, min_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, safe_allocator<T>>();
+
+    if constexpr (std::sentinel_for<Iter, Iter>) {
+      f.template operator()<Iter, Iter, std::allocator<T>>();
+      f.template operator()<Iter, Iter, test_allocator<T>>();
+      f.template operator()<Iter, Iter, min_allocator<T>>();
+      f.template operator()<Iter, Iter, safe_allocator<T>>();
+    }
+  });
+}
+
+#endif // SUPPORT_FROM_RANGE_HELPERS_H
diff --git a/libcxx/test/std/containers/insert_range_helpers.h b/libcxx/test/std/containers/insert_range_helpers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/insert_range_helpers.h
@@ -0,0 +1,123 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_INSERT_RANGE_HELPERS_H
+#define SUPPORT_INSERT_RANGE_HELPERS_H
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <map>
+#include <ranges>
+#include <set>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "from_range_helpers.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+
+// A simple literal-type container. It can be used as a `constexpr` global variable (which isn't supported by
+// `std::vector`).
+template <class T, std::size_t N = 32>
+class Buffer {
+ public:
+  constexpr Buffer() = default;
+
+  constexpr Buffer(std::initializer_list<T> input) {
+    assert(input.size() <= N);
+    std::ranges::copy(input, data_);
+    size_ = input.size();
+  }
+
+  // Makes initializing `Buffer<char>` nicer -- allows writing `buf = "abc"` instead of `buf = {'a', 'b', 'c'}`.
+  // To make the two forms equivalent, omits the terminating null.
+  template <std::size_t N2>
+  constexpr Buffer(const char (&input) [N2])
+  requires std::same_as<T, char> {
+    static_assert(N2 <= N);
+    std::ranges::copy(input, data_);
+    // Omit the terminating null.
+    size_ = input[N2 - 1] == '\0' ? N2 - 1 : N2;
+  }
+
+  constexpr const T* begin() const { return data_; }
+  constexpr const T* end() const { return data_ + size_; }
+  constexpr std::size_t size() const { return size_; }
+
+ private:
+  std::size_t size_ = 0;
+  T data_[N] = {};
+};
+
+template <class T>
+struct TestCase {
+  Buffer<T> initial;
+  std::size_t index = 0;
+  Buffer<T> input;
+  Buffer<T> expected;
+};
+
+template <class T, class PtrT, class Func>
+constexpr void for_all_iterators_and_allocators(Func f) {
+  using Iterators = types::type_list<
+    cpp20_input_iterator<PtrT>,
+    forward_iterator<PtrT>,
+    bidirectional_iterator<PtrT>,
+    random_access_iterator<PtrT>,
+    contiguous_iterator<PtrT>,
+    PtrT
+  >;
+
+  types::for_each(Iterators{}, [=]<class Iter>() {
+    f.template operator()<Iter, sentinel_wrapper<Iter>, std::allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, test_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, min_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, safe_allocator<T>>();
+
+    if constexpr (std::sentinel_for<Iter, Iter>) {
+      f.template operator()<Iter, Iter, std::allocator<T>>();
+      f.template operator()<Iter, Iter, test_allocator<T>>();
+      f.template operator()<Iter, Iter, min_allocator<T>>();
+      f.template operator()<Iter, Iter, safe_allocator<T>>();
+    }
+  });
+}
+
+// Uses a shorter list of iterator types for use in `constexpr` mode for cases when running the full set in would take
+// too long.
+template <class T, class PtrT, class Func>
+constexpr void for_all_iterators_and_allocators_constexpr(Func f) {
+  using Iterators = types::type_list<
+    cpp20_input_iterator<PtrT>,
+    forward_iterator<PtrT>,
+    PtrT
+  >;
+
+  types::for_each(Iterators{}, [=]<class Iter>() {
+    f.template operator()<Iter, sentinel_wrapper<Iter>, std::allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, test_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, min_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, safe_allocator<T>>();
+
+    if constexpr (std::sentinel_for<Iter, Iter>) {
+      f.template operator()<Iter, Iter, std::allocator<T>>();
+      f.template operator()<Iter, Iter, test_allocator<T>>();
+      f.template operator()<Iter, Iter, min_allocator<T>>();
+      f.template operator()<Iter, Iter, safe_allocator<T>>();
+    }
+  });
+}
+
+#endif // SUPPORT_INSERT_RANGE_HELPERS_H
diff --git a/libcxx/test/std/containers/insert_range_maps_sets.h b/libcxx/test/std/containers/insert_range_maps_sets.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/insert_range_maps_sets.h
@@ -0,0 +1,414 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_INSERT_RANGE_MAPS_SETS_H
+#define SUPPORT_INSERT_RANGE_MAPS_SETS_H
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <ranges>
+#include <type_traits>
+#include <vector>
+
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "insert_range_helpers.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_compare.h"
+#include "test_hash.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+
+template <class Container, class Range>
+concept HasInsertRange = requires (Container& c, Range&& range) {
+  c.insert_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_set_constraints_insert_range() {
+  // Input range with the same value type.
+  static_assert(HasInsertRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasInsertRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasInsertRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <template <class...> class Container, class K, class V, class K2, class V2>
+constexpr bool test_map_constraints_insert_range() {
+  using ValueType = std::pair<const K, V>;
+
+  // Input range with the same value type.
+  static_assert(HasInsertRange<Container<K, V>, InputRange<ValueType>>);
+  // Input range with a convertible value type.
+  static_assert(HasInsertRange<Container<K, V>, InputRange<std::pair<const K2, V2>>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasInsertRange<Container<K, V>, InputRange<std::pair<const K, Empty>>>);
+  static_assert(!HasInsertRange<Container<K, V>, InputRange<std::pair<const Empty, V>>>);
+  // Not an input range.
+  static_assert(!HasInsertRange<Container<K, V>, InputRangeNotDerivedFromGeneric<ValueType>>);
+
+  return true;
+}
+
+template <class T>
+struct TestCaseMapSet {
+  Buffer<T> initial;
+  Buffer<T> input;
+  Buffer<T> expected;
+  Buffer<T> expected_multi;
+};
+
+// Empty container.
+
+template <class T>
+TestCaseMapSet<T> constexpr EmptyContainer_EmptyRange {
+  .initial = {}, .input = {}, .expected = {}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr EmptyContainer_OneElementRange {
+  .initial = {}, .input = {1}, .expected = {1}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr EmptyContainer_OneElementRange<std::pair<K, V>> {
+  .initial = {}, .input = {{1, 'a'}}, .expected = {{1, 'a'}}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr EmptyContainer_RangeNoDuplicates {
+  .initial = {}, .input = {5, 1, 3, 8, 6}, .expected = {5, 1, 3, 8, 6}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr EmptyContainer_RangeNoDuplicates<std::pair<K, V>> {
+  .initial = {}, .input = {{5, 'a'}, {1, 'e'}, {3, 'i'}, {8, 'o'}, {6, 'u'}},
+  .expected = {{5, 'a'}, {1, 'e'}, {3, 'i'}, {8, 'o'}, {6, 'u'}}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr EmptyContainer_RangeWithDuplicates {
+  .initial = {},
+  .input = {5, 1, 1, 3, 5, 8, 5, 6, 10},
+  .expected = {5, 1, 3, 8, 6, 10},
+  .expected_multi = {5, 1, 1, 3, 5, 8, 5, 6, 10}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr EmptyContainer_RangeWithDuplicates<std::pair<K, V>> {
+  .initial = {},
+  .input = {{5, 'a'}, {1, 'a'}, {1, 'b'}, {3, 'a'}, {5, 'b'}, {8, 'a'}, {5, 'c'}, {6, 'a'}, {10, 'b'}},
+  .expected = {{5, 'a'}, {1, 'a'}, {3, 'a'}, {8, 'a'}, {6, 'a'}, {10, 'b'}},
+  .expected_multi = {{5, 'a'}, {1, 'a'}, {1, 'b'}, {3, 'a'}, {5, 'b'}, {8, 'a'}, {5, 'c'}, {6, 'a'}, {10, 'b'}}
+};
+
+// One-element container.
+
+template <class T>
+TestCaseMapSet<T> constexpr OneElementContainer_EmptyRange {
+  .initial = {10}, .input = {}, .expected = {10}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr OneElementContainer_EmptyRange<std::pair<K, V>> {
+  .initial = {{10, 'A'}}, .input = {}, .expected = {{10, 'A'}}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr OneElementContainer_OneElementRange {
+  .initial = {10}, .input = {1}, .expected = {1, 10}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr OneElementContainer_OneElementRange<std::pair<K, V>> {
+  .initial = {{10, 'A'}}, .input = {{1, 'a'}}, .expected = {{1, 'a'}, {10, 'A'}}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr OneElementContainer_RangeNoDuplicates {
+  .initial = {10}, .input = {5, 1, 3, 8, 6}, .expected = {5, 1, 3, 8, 6, 10}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr OneElementContainer_RangeNoDuplicates<std::pair<K, V>> {
+  .initial = {{10, 'A'}}, .input = {{5, 'a'}, {1, 'e'}, {3, 'i'}, {8, 'o'}, {6, 'u'}},
+  .expected = {{5, 'a'}, {1, 'e'}, {3, 'i'}, {8, 'o'}, {6, 'u'}, {10, 'A'}}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr OneElementContainer_RangeWithDuplicates {
+  .initial = {10},
+  .input = {5, 1, 1, 3, 5, 8, 5, 6, 10},
+  .expected = {5, 1, 3, 8, 6, 10},
+  .expected_multi = {5, 1, 1, 3, 5, 8, 5, 6, 10, 10}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr OneElementContainer_RangeWithDuplicates<std::pair<K, V>> {
+  .initial = {{10, 'A'}},
+  .input = {{5, 'a'}, {1, 'a'}, {1, 'b'}, {3, 'a'}, {5, 'b'}, {8, 'a'}, {5, 'c'}, {6, 'a'}, {10, 'b'}},
+  .expected = {{5, 'a'}, {1, 'a'}, {3, 'a'}, {8, 'a'}, {6, 'a'}, {10, 'A'}},
+  .expected_multi = {
+    {5, 'a'}, {1, 'a'}, {1, 'b'}, {3, 'a'}, {5, 'b'}, {8, 'a'}, {5, 'c'}, {6, 'a'}, {10, 'A'}, {10, 'b'}
+  }
+};
+
+// Full container.
+
+template <class T>
+TestCaseMapSet<T> constexpr FullContainer_EmptyRange {
+  .initial = {10, 15, 19, 16}, .input = {}, .expected = {10, 15, 19, 16}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr FullContainer_EmptyRange<std::pair<K, V>> {
+  .initial = {{10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}}, .input = {},
+  .expected = {{10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr FullContainer_OneElementRange {
+  .initial = {10, 15, 19, 16}, .input = {1}, .expected = {1, 10, 15, 19, 16}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr FullContainer_OneElementRange<std::pair<K, V>> {
+  .initial = {{10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}}, .input = {{1, 'a'}},
+  .expected = {{1, 'a'}, {10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr FullContainer_RangeNoDuplicates {
+  .initial = {10, 15, 19, 16}, .input = {5, 1, 3, 8, 6}, .expected = {5, 1, 3, 8, 6, 10, 15, 19, 16}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr FullContainer_RangeNoDuplicates<std::pair<K, V>> {
+  .initial = {{10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}},
+  .input = {{5, 'a'}, {1, 'e'}, {3, 'i'}, {8, 'o'}, {6, 'u'}},
+  .expected = {{5, 'a'}, {1, 'e'}, {3, 'i'}, {8, 'o'}, {6, 'u'}, {10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}}
+};
+
+template <class T>
+TestCaseMapSet<T> constexpr FullContainer_RangeWithDuplicates {
+  .initial = {10, 15, 19, 16},
+  .input = {5, 1, 1, 3, 5, 8, 5, 6, 10},
+  .expected = {5, 1, 3, 8, 6, 10, 15, 19, 16},
+  .expected_multi = {5, 1, 1, 3, 5, 8, 5, 6, 10, 10, 15, 19, 16}
+};
+template <class K, class V> TestCaseMapSet<std::pair<K, V>>
+constexpr FullContainer_RangeWithDuplicates<std::pair<K, V>> {
+  .initial = {{10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}},
+  .input = {{5, 'a'}, {1, 'a'}, {1, 'b'}, {3, 'a'}, {5, 'b'}, {8, 'a'}, {5, 'c'}, {6, 'a'}, {10, 'b'}},
+  .expected = {{5, 'a'}, {1, 'a'}, {3, 'a'}, {8, 'a'}, {6, 'a'}, {10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}},
+  .expected_multi = {
+    {5, 'a'}, {1, 'a'}, {1, 'b'}, {3, 'a'}, {5, 'b'}, {8, 'a'}, {5, 'c'}, {6, 'a'}, {10, 'b'},
+    {10, 'A'}, {15, 'B'}, {19, 'C'}, {16, 'D'}
+  }
+};
+
+template <class Container, class T, class Iter, class Sent>
+void test_map_set_insert_range(bool allow_duplicates = false) {
+  auto test = [&](const TestCaseMapSet<T>& test_case, bool check_multi = false) {
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+
+    c.insert_range(in);
+    if (check_multi) {
+      return std::ranges::is_permutation(c, test_case.expected_multi);
+    } else {
+      return std::ranges::is_permutation(c, test_case.expected);
+    }
+  };
+
+  { // Empty container.
+    // empty_c.insert_range(empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.insert_range(one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.insert_range(range_no_duplicates)
+    assert(test(EmptyContainer_RangeNoDuplicates<T>));
+    // empty_c.insert_range(range_with_duplicates)
+    assert(test(EmptyContainer_RangeWithDuplicates<T>, allow_duplicates));
+  }
+
+  { // One-element container.
+    // one_element_c.insert_range(empty_range)
+    assert(test(OneElementContainer_EmptyRange<T>));
+    // one_element_c.insert_range(one_element_range)
+    assert(test(OneElementContainer_OneElementRange<T>));
+    // one_element_c.insert_range(range_no_duplicates)
+    assert(test(OneElementContainer_RangeNoDuplicates<T>));
+    // one_element_c.insert_range(range_with_duplicates)
+    assert(test(OneElementContainer_RangeWithDuplicates<T>, allow_duplicates));
+  }
+
+  { // Full container.
+    // full_c.insert_range(empty_range)
+    assert(test(FullContainer_EmptyRange<T>));
+    // full_c.insert_range(one_element_range)
+    assert(test(FullContainer_OneElementRange<T>));
+    // full_c.insert_range(range_no_duplicates)
+    assert(test(FullContainer_RangeNoDuplicates<T>));
+    // full_c.insert_range(range_with_duplicates)
+    assert(test(FullContainer_RangeWithDuplicates<T>, allow_duplicates));
+  }
+}
+
+// Move-only types.
+
+template <template <class ...> class Container>
+void test_set_insert_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.insert_range(in);
+}
+
+template <template <class ...> class Container>
+void test_map_insert_range_move_only() {
+  using Value = std::pair<const int, MoveOnly>;
+  Value input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<int, MoveOnly> c;
+  c.insert_range(in);
+}
+
+// Exception safety.
+
+template <template <class ...> class Container>
+void test_set_insert_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5] = {{1}, {2}, {3}, {4}, {5}};
+
+  try {
+    Container<T> c;
+    c.insert_range(in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container>
+void test_map_insert_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using K = int;
+  using V = ThrowingCopy<3>;
+
+  V::throwing_enabled = false;
+  std::pair<const K, V> in[5] = {
+    {1, {}}, {2, {}}, {3, {}}, {4, {}}, {5, {}}
+  };
+  V::throwing_enabled = true;
+  V::reset();
+
+  try {
+    Container<K, V> c;
+    c.insert_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(V::created_by_copying == 3);
+    assert(V::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_assoc_set_insert_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {1, 2};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, test_less<T>, ThrowingAllocator<T>> c(alloc);
+    c.insert_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_unord_set_insert_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {1, 2};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, test_hash<T>, test_equal_to<T>, ThrowingAllocator<T>> c(alloc);
+    c.insert_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container, class K, class V>
+void test_assoc_map_insert_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using ValueType = std::pair<const K, V>;
+  ValueType in[] = {
+    ValueType{K{1}, V{1}}
+  };
+
+  try {
+    ThrowingAllocator<ValueType> alloc;
+
+    globalMemCounter.reset();
+    Container<K, V, test_less<K>, ThrowingAllocator<ValueType>> c(alloc);
+    c.insert_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container, class K, class V>
+void test_unord_map_insert_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using ValueType = std::pair<const K, V>;
+  ValueType in[] = {
+    ValueType{K{1}, V{1}}
+  };
+
+  try {
+    ThrowingAllocator<ValueType> alloc;
+
+    globalMemCounter.reset();
+    Container<K, V, test_hash<K>, test_equal_to<K>, ThrowingAllocator<ValueType>> c(alloc);
+    c.insert_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_INSERT_RANGE_MAPS_SETS_H
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
@@ -13,12 +13,16 @@
 //    deque(InputIterator, InputIterator, Allocator = Allocator())
 //    -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
+// template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+//   deque(from_range_t, R&&, Allocator = Allocator())
+//     -> deque<ranges::range_value_t<R>, Allocator>; // C++23
 
-#include <deque>
-#include <iterator>
+#include <array>
 #include <cassert>
-#include <cstddef>
 #include <climits> // INT_MAX
+#include <cstddef>
+#include <deque>
+#include <iterator>
 
 #include "deduction_guides_sfinae_checks.h"
 #include "test_macros.h"
@@ -122,6 +126,21 @@
         }
     }
 
+#if TEST_STD_VER >= 23
+    {
+      {
+        std::deque c(std::from_range, std::array<int, 0>());
+        static_assert(std::is_same_v<decltype(c), std::deque<int>>);
+      }
+
+      {
+        using Alloc = test_allocator<int>;
+        std::deque c(std::from_range, std::array<int, 0>(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::deque<int, Alloc>>);
+      }
+    }
+#endif
+
     SequenceContainerDeductionGuidesSfinaeAway<std::deque, std::deque<int>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/from_range.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/from_range.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <deque>
+
+#include "../../from_range_sequence_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R>
+//   deque(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_container<std::deque, int, Iter, Sent, Alloc>([](const auto& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+  test_sequence_container_move_only<std::deque>();
+
+  static_assert(test_constraints<std::deque, int, double>());
+
+  // TODO(varconst): `deque`'s constructors currently aren't exception-safe.
+  // See https://github.com/llvm/llvm-project/issues/62056.
+  //test_exception_safety_throwing_copy<std::deque>();
+  //test_exception_safety_throwing_allocator<std::deque, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/append_range.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/append_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/append_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr void append_range(R&& rg); // C++23
+
+#include <deque>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (appending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - appending move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_append_range<std::deque, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_append_range<std::deque<int, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+  test_sequence_append_range_move_only<std::deque>();
+
+  test_append_range_exception_safety_throwing_copy<std::deque>();
+  test_append_range_exception_safety_throwing_allocator<std::deque, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/assign_range.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/assign_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/assign_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr void assign_range(R&& rg); // C++23
+
+#include <deque>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of assignments (assigning an {empty/one-element/mid-sized/long range} to an
+//   {empty/one-element/full} container);
+// - assigning move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_assign_range<std::deque, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_assign_range<std::deque<int, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+  test_sequence_assign_range_move_only<std::deque>();
+
+  test_assign_range_exception_safety_throwing_copy<std::deque>();
+  test_assign_range_exception_safety_throwing_allocator<std::deque, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
+
+#include <deque>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (inserting an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container at the {beginning/middle/end});
+// - inserting move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_insert_range<std::deque, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range<std::deque<int, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+  test_sequence_insert_range_move_only<std::deque>();
+
+  test_insert_range_exception_safety_throwing_copy<std::deque>();
+  test_insert_range_exception_safety_throwing_allocator<std::deque, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/prepend_range.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/prepend_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/prepend_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr void prepend_range(R&& rg); // C++23
+
+#include <deque>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (prepending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - prepending move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_prepend_range<std::deque, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_prepend_range<std::deque<int, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+  test_sequence_prepend_range_move_only<std::deque>();
+
+  test_prepend_range_exception_safety_throwing_copy<std::deque>();
+  test_prepend_range_exception_safety_throwing_allocator<std::deque, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
@@ -13,8 +13,12 @@
 //    forward_list(InputIterator, InputIterator, Allocator = Allocator())
 //    -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
+// template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+//   forward_list(from_range_t, R&&, Allocator = Allocator())
+//       -> forward_list<ranges::range_value_t<R>, Allocator>; // C++23
 
 #include <algorithm>
+#include <array>
 #include <forward_list>
 #include <iterator>
 #include <cassert>
@@ -128,6 +132,21 @@
         }
     }
 
+#if TEST_STD_VER >= 23
+    {
+      {
+        std::forward_list c(std::from_range, std::array<int, 0>());
+        static_assert(std::is_same_v<decltype(c), std::forward_list<int>>);
+      }
+
+      {
+        using Alloc = test_allocator<int>;
+        std::forward_list c(std::from_range, std::array<int, 0>(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::forward_list<int, Alloc>>);
+      }
+    }
+#endif
+
     SequenceContainerDeductionGuidesSfinaeAway<std::forward_list, std::forward_list<int>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/from_range.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/from_range.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <forward_list>
+
+#include "../../from_range_sequence_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R>
+//   forward_list(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_container<std::forward_list, int, Iter, Sent, Alloc>([](const auto&) {
+      // No additional validation to do.
+    });
+  });
+  test_sequence_container_move_only<std::forward_list>();
+
+  static_assert(test_constraints<std::forward_list, int, double>());
+
+  test_exception_safety_throwing_copy<std::forward_list>();
+  test_exception_safety_throwing_allocator<std::forward_list, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/assign_range.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/assign_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/assign_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr void prepend_range(R&& rg); // C++23
+
+#include <forward_list>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (prepending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - prepending move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_assign_range<std::forward_list, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_prepend_range<std::forward_list<int, Alloc>, Iter, Sent>([](auto&&) {
+      // No additional validation to do.
+    });
+  });
+  test_sequence_prepend_range_move_only<std::forward_list>();
+
+  test_prepend_range_exception_safety_throwing_copy<std::forward_list>();
+  test_prepend_range_exception_safety_throwing_allocator<std::forward_list, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_range_after.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_range_after.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_range_after.pass.cpp
@@ -0,0 +1,383 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr iterator insert_range_after(const_iterator position, R&& rg); // C++23
+
+#include <forward_list>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+template <class Container, class Range>
+concept HasInsertRangeAfter = requires (Container& c, Range&& range) {
+  c.insert_range_after(c.begin(), range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_insert_range_after() {
+  // Input range with the same value type.
+  static_assert(HasInsertRangeAfter<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasInsertRangeAfter<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasInsertRangeAfter<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasInsertRangeAfter<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasInsertRangeAfter<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasInsertRangeAfter<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+// Tested cases:
+// - different kinds of insertions (inserting an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container at the {beginning/middle/end});
+// - inserting move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+
+template <class T, class Iter, class Sent, class Alloc>
+constexpr void test_sequence_insert_range_after() {
+  using Container = std::forward_list<T, Alloc>;
+  // Index `0` translates to `before_begin()` and the last index translates to the index before `end()`.
+  auto get_insert_pos = [](auto& c, auto& test_case) { return std::ranges::next(c.before_begin(), test_case.index); };
+  // Unlike `insert_range` in other containers, `insert_range_after` returns the iterator to the last inserted element.
+  auto get_return_pos = [](auto& c, auto& test_case) {
+    return std::ranges::next(c.before_begin(), test_case.index + test_case.input.size());
+  };
+
+  { // Empty container.
+    { // empty_c.insert_range_after(end, empty_range)
+      auto& test_case = EmptyContainer_EmptyRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // empty_c.insert_range_after(end, one_element_range)
+      auto& test_case = EmptyContainer_OneElementRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // empty_c.insert_range_after(end, mid_range)
+      auto& test_case = EmptyContainer_MidRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+  }
+
+  { // One-element container.
+    { // one_element_c.insert_range_after(begin, empty_range)
+      auto& test_case = OneElementContainer_Begin_EmptyRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // one_element_c.insert_range_after(end, empty_range)
+      auto& test_case = OneElementContainer_End_EmptyRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // one_element_c.insert_range_after(begin, one_element_range)
+      auto& test_case = OneElementContainer_Begin_OneElementRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // one_element_c.insert_range_after(end, one_element_range)
+      auto& test_case = OneElementContainer_End_OneElementRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // one_element_c.insert_range_after(begin, mid_range)
+      auto& test_case = OneElementContainer_Begin_MidRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // one_element_c.insert_range_after(end, mid_range)
+      auto& test_case = OneElementContainer_End_MidRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+  }
+
+  { // Full container.
+    { // full_container.insert_range_after(begin, empty_range)
+      auto& test_case = FullContainer_Begin_EmptyRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(mid, empty_range)
+      auto& test_case = FullContainer_Mid_EmptyRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(end, empty_range)
+      auto& test_case = FullContainer_End_EmptyRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(begin, one_element_range)
+      auto& test_case = FullContainer_Begin_OneElementRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(end, one_element_range)
+      auto& test_case = FullContainer_Mid_OneElementRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(end, one_element_range)
+      auto& test_case = FullContainer_End_OneElementRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(begin, mid_range)
+      auto& test_case = FullContainer_Begin_MidRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(mid, mid_range)
+      auto& test_case = FullContainer_Mid_MidRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(end, mid_range)
+      auto& test_case = FullContainer_End_MidRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(begin, long_range)
+      auto& test_case = FullContainer_Begin_LongRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(mid, long_range)
+      auto& test_case = FullContainer_Mid_LongRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+
+    { // full_container.insert_range_after(end, long_range)
+      auto& test_case = FullContainer_End_LongRange<T>;
+
+      Container c(test_case.initial.begin(), test_case.initial.end());
+      auto in = wrap_input<Iter, Sent>(test_case.input);
+      auto pos = get_insert_pos(c, test_case);
+
+      auto result = c.insert_range_after(pos, in);
+      assert(std::ranges::equal(c, test_case.expected));
+      assert(result == get_return_pos(c, test_case));
+    }
+  }
+
+  // Also check inserting after `begin()` (the tests above only use `before_begin()`).
+  {
+    Container c{5, 1, 3, 4, 9};
+    Buffer<T> input{-18, -15, -11};
+    auto in = wrap_input<Iter, Sent>(input);
+
+    auto result = c.insert_range_after(c.begin(), in);
+    assert(std::ranges::equal(c, Buffer<int>{5, -18, -15, -11, 1, 3, 4, 9}));
+    assert(result == std::ranges::next(c.begin(), 3));
+  }
+}
+
+void test_sequence_insert_range_after_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  std::forward_list<MoveOnly> c;
+  c.insert_range_after(c.before_begin(), in);
+}
+
+void test_insert_range_after_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    std::forward_list<T> c;
+    c.insert_range_after(c.before_begin(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <class T>
+void test_insert_range_after_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    std::forward_list<T, ThrowingAllocator<T>> c(alloc);
+    c.insert_range_after(c.before_begin(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+int main(int, char**) {
+  static_assert(test_constraints_insert_range_after<std::forward_list, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range_after<int, Iter, Sent, Alloc>();
+  });
+  test_sequence_insert_range_after_move_only();
+
+  test_insert_range_after_exception_safety_throwing_copy();
+  test_insert_range_after_exception_safety_throwing_allocator<int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/prepend_range.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/prepend_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/prepend_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr void prepend_range(R&& rg); // C++23
+
+#include <forward_list>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (prepending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - prepending move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_prepend_range<std::forward_list, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_prepend_range<std::forward_list<int, Alloc>, Iter, Sent>([](auto&&) {
+      // No additional validation to do.
+    });
+  });
+  test_sequence_prepend_range_move_only<std::forward_list>();
+
+  test_prepend_range_exception_safety_throwing_copy<std::forward_list>();
+  test_prepend_range_exception_safety_throwing_allocator<std::forward_list, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/from_range_sequence_containers.h b/libcxx/test/std/containers/sequences/from_range_sequence_containers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/from_range_sequence_containers.h
@@ -0,0 +1,161 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_FROM_RANGE_SEQUENCE_CONTAINERS_H
+#define SUPPORT_FROM_RANGE_SEQUENCE_CONTAINERS_H
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <ranges>
+#include <utility>
+
+#include "../from_range_helpers.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+template <class T>
+concept HasSize = requires (const T& value) { value.size(); };
+
+template <class Container, class Range>
+concept HasFromRangeCtr = requires (Range&& range) {
+  Container(std::from_range, std::forward<Range>(range));
+  Container(std::from_range, std::forward<Range>(range), std::allocator<typename Container::value_type>());
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints() {
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  // Note: there are no constraints on the allocator (it's not a separate template type of the constructor)`.
+
+  return true;
+}
+
+// Note: `std::array` is used to avoid dealing with `vector<bool>`.
+template <template <class ...> class Container,
+          class T,
+          class Iter,
+          class Sent,
+          class Alloc,
+          std::size_t N,
+          class ValidateFunc>
+constexpr void test_sequence_container_with_input(std::array<T, N>&& input, ValidateFunc validate) {
+  auto in = wrap_input<Iter, Sent>(input);
+
+  { // (range)
+    Container<T> c(std::from_range, in);
+
+    if constexpr (HasSize<Container<T>>) {
+      assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    }
+    assert(std::ranges::equal(in, c));
+    validate(c);
+  }
+
+  { // (range, allocator)
+    Alloc alloc;
+    Container<T, Alloc> c(std::from_range, in, alloc);
+
+    assert(c.get_allocator() == alloc);
+    if constexpr (HasSize<Container<T, Alloc>>) {
+      assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    }
+    assert(std::ranges::equal(in, c));
+    validate(c);
+  }
+}
+
+template <template <class ...> class Container,
+          class T,
+          class Iter,
+          class Sent,
+          class Alloc,
+          class ValidateFunc>
+constexpr void test_sequence_container(ValidateFunc validate) {
+  // Normal input.
+  test_sequence_container_with_input<Container, T, Iter, Sent, Alloc>(std::array{0, 5, 12, 7, -1, 8, 26}, validate);
+  // Empty input.
+  test_sequence_container_with_input<Container, T, Iter, Sent, Alloc>(std::array<int, 0>{}, validate);
+  // Single-element input.
+  test_sequence_container_with_input<Container, T, Iter, Sent, Alloc>(std::array{5}, validate);
+}
+
+template <template <class ...> class Container>
+constexpr void test_sequence_container_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  [[maybe_unused]] Container<MoveOnly> c(std::from_range, in);
+}
+
+template <class Iter,
+          class Sent,
+          class Alloc,
+          class ValidateFunc>
+constexpr void test_vector_bool(ValidateFunc validate) {
+  // Normal input.
+  test_sequence_container_with_input<std::vector, bool, Iter, Sent, Alloc>(
+      std::array{true, false, false, true, false, true, true, true, false, true}, validate);
+  // Empty input.
+  test_sequence_container_with_input<std::vector, bool, Iter, Sent, Alloc>(std::array<bool, 0>{}, validate);
+  // Single-element input.
+  test_sequence_container_with_input<std::vector, bool, Iter, Sent, Alloc>(std::array{true}, validate);
+}
+
+template <template <class ...> class Container>
+void test_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c(std::from_range, in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(std::from_range, in, alloc);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_FROM_RANGE_SEQUENCE_CONTAINERS_H
diff --git a/libcxx/test/std/containers/sequences/insert_range_sequence_containers.h b/libcxx/test/std/containers/sequences/insert_range_sequence_containers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/insert_range_sequence_containers.h
@@ -0,0 +1,827 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H
+#define SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <cstddef>
+#include <initializer_list>
+#include <ranges>
+#include <type_traits>
+#include <vector>
+
+#include "../from_range_helpers.h"
+#include "../insert_range_helpers.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+
+template <class Container, class Range>
+concept HasInsertRange = requires (Container& c, Range&& range) {
+  c.insert_range(c.end(), range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_insert_range() {
+  // Input range with the same value type.
+  static_assert(HasInsertRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasInsertRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasInsertRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <class Container, class Range>
+concept HasAppendRange = requires (Container& c, Range&& range) {
+  c.append_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_append_range() {
+  // Input range with the same value type.
+  static_assert(HasAppendRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasAppendRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasAppendRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasAppendRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasAppendRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasAppendRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <class Container, class Range>
+concept HasPrependRange = requires (Container& c, Range&& range) {
+  c.prepend_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_prepend_range() {
+  // Input range with the same value type.
+  static_assert(HasPrependRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasPrependRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasPrependRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasPrependRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasPrependRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasPrependRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <class Container, class Range>
+concept HasAssignRange = requires (Container& c, Range&& range) {
+  c.assign_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_assign_range() {
+  // Input range with the same value type.
+  static_assert(HasAssignRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasAssignRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasAssignRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasAssignRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasAssignRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasAssignRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+// Empty container.
+
+template <class T>
+TestCase<T> constexpr EmptyContainer_EmptyRange {
+  .initial = {}, .index = 0, .input = {}, .expected = {}
+};
+// Note: specializations for `bool` still use `vector<int>` for inputs. This is to avoid dealing with `vector<bool>` and
+// its iterators over proxy types.
+template <> constexpr TestCase<int> EmptyContainer_EmptyRange<bool> {
+  .initial = {}, .index = 0, .input = {}, .expected = {}
+};
+
+template <class T> constexpr TestCase<T> EmptyContainer_OneElementRange;
+template <> constexpr TestCase<int> EmptyContainer_OneElementRange<int> {
+  .initial = {}, .index = 0, .input = {5}, .expected = {5}
+};
+template <> constexpr TestCase<char> EmptyContainer_OneElementRange<char> {
+  .initial = {}, .index = 0, .input = "a", .expected = "a"
+};
+template <> constexpr TestCase<int> EmptyContainer_OneElementRange<bool> {
+  .initial = {}, .index = 0, .input = {true}, .expected = {true}
+};
+
+template <class T> constexpr TestCase<T> EmptyContainer_MidRange;
+template <> constexpr TestCase<int> EmptyContainer_MidRange<int> {
+  .initial = {}, .index = 0, .input = {5, 3, 1, 7, 9}, .expected = {5, 3, 1, 7, 9}
+};
+template <> constexpr TestCase<char> EmptyContainer_MidRange<char> {
+  .initial = {}, .index = 0, .input = "aeiou", .expected = "aeiou"
+};
+template <> constexpr TestCase<int> EmptyContainer_MidRange<bool> {
+  .initial = {}, .index = 0, .input = {1, 1, 0, 1, 1}, .expected = {1, 1, 0, 1, 1}
+};
+
+// One-element container.
+
+template <class T> constexpr TestCase<T> OneElementContainer_Begin_EmptyRange;
+template <> constexpr TestCase<int> OneElementContainer_Begin_EmptyRange<int> {
+  .initial = {3}, .index = 0, .input = {}, .expected = {3}
+};
+template <> constexpr TestCase<char> OneElementContainer_Begin_EmptyRange<char> {
+  .initial = "B", .index = 0, .input = {}, .expected = "B"
+};
+template <> constexpr TestCase<int> OneElementContainer_Begin_EmptyRange<bool> {
+  .initial = {0}, .index = 0, .input = {}, .expected = {0}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_End_EmptyRange;
+template <> constexpr TestCase<int> OneElementContainer_End_EmptyRange<int> {
+  .initial = {3}, .index = 1, .input = {}, .expected = {3}
+};
+template <> constexpr TestCase<char> OneElementContainer_End_EmptyRange<char> {
+  .initial = "B", .index = 1, .input = {}, .expected = "B"
+};
+template <> constexpr TestCase<int> OneElementContainer_End_EmptyRange<bool> {
+  .initial = {0}, .index = 1, .input = {}, .expected = {0}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_Begin_OneElementRange;
+template <> constexpr TestCase<int> OneElementContainer_Begin_OneElementRange<int> {
+  .initial = {3}, .index = 0, .input = {-5}, .expected = {-5, 3}
+};
+template <> constexpr TestCase<char> OneElementContainer_Begin_OneElementRange<char> {
+  .initial = "B", .index = 0, .input = "a", .expected = "aB"
+};
+template <> constexpr TestCase<int> OneElementContainer_Begin_OneElementRange<bool> {
+  .initial = {0}, .index = 0, .input = {1}, .expected = {1, 0}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_End_OneElementRange;
+template <> constexpr TestCase<int> OneElementContainer_End_OneElementRange<int> {
+  .initial = {3}, .index = 1, .input = {-5}, .expected = {3, -5}
+};
+template <> constexpr TestCase<char> OneElementContainer_End_OneElementRange<char> {
+  .initial = "B", .index = 1, .input = "a", .expected = "Ba"
+};
+template <> constexpr TestCase<int> OneElementContainer_End_OneElementRange<bool> {
+  .initial = {0}, .index = 1, .input = {1}, .expected = {0, 1}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_Begin_MidRange;
+template <> constexpr TestCase<int> OneElementContainer_Begin_MidRange<int> {
+  .initial = {3}, .index = 0, .input = {-5, -3, -1, -7, -9}, .expected = {-5, -3, -1, -7, -9, 3}
+};
+template <> constexpr TestCase<char> OneElementContainer_Begin_MidRange<char> {
+  .initial = "B", .index = 0, .input = "aeiou", .expected = "aeiouB"
+};
+template <> constexpr TestCase<int> OneElementContainer_Begin_MidRange<bool> {
+  .initial = {0}, .index = 0, .input = {1, 1, 0, 1, 1}, .expected = {1, 1, 0, 1, 1, 0}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_End_MidRange;
+template <> constexpr TestCase<int> OneElementContainer_End_MidRange<int> {
+  .initial = {3}, .index = 1, .input = {-5, -3, -1, -7, -9}, .expected = {3, -5, -3, -1, -7, -9}
+};
+template <> constexpr TestCase<char> OneElementContainer_End_MidRange<char> {
+  .initial = "B", .index = 1, .input = "aeiou", .expected = "Baeiou"
+};
+template <> constexpr TestCase<int> OneElementContainer_End_MidRange<bool> {
+  .initial = {0}, .index = 1, .input = {1, 1, 0, 1, 1}, .expected = {0, 1, 1, 0, 1, 1}
+};
+
+// Full container / empty range.
+
+template <class T> constexpr TestCase<T> FullContainer_Begin_EmptyRange;
+template <> constexpr TestCase<int> FullContainer_Begin_EmptyRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 0, .input = {}, .expected = {11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Begin_EmptyRange<char> {
+  .initial = "_BCD_", .index = 0, .input = {}, .expected = "_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Begin_EmptyRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 0, .input = {}, .expected = {0, 0, 1, 0, 0}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_Mid_EmptyRange;
+template <> constexpr TestCase<int> FullContainer_Mid_EmptyRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 2, .input = {}, .expected = {11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Mid_EmptyRange<char> {
+  .initial = "_BCD_", .index = 2, .input = {}, .expected = "_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Mid_EmptyRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 2, .input = {}, .expected = {0, 0, 1, 0, 0}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_End_EmptyRange;
+template <> constexpr TestCase<int> FullContainer_End_EmptyRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 5, .input = {}, .expected = {11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_End_EmptyRange<char> {
+  .initial = "_BCD_", .index = 5, .input = {}, .expected = "_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_End_EmptyRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 5, .input = {}, .expected = {0, 0, 1, 0, 0}
+};
+
+// Full container / one-element range.
+
+template <class T> constexpr TestCase<T> FullContainer_Begin_OneElementRange;
+template <> constexpr TestCase<int> FullContainer_Begin_OneElementRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 0, .input = {-5}, .expected = {-5, 11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Begin_OneElementRange<char> {
+  .initial = "_BCD_", .index = 0, .input = "a", .expected = "a_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Begin_OneElementRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 0, .input = {1}, .expected = {1, 0, 0, 1, 0, 0}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_Mid_OneElementRange;
+template <> constexpr TestCase<int> FullContainer_Mid_OneElementRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 2, .input = {-5}, .expected = {11, 29, -5, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Mid_OneElementRange<char> {
+  .initial = "_BCD_", .index = 2, .input = "a", .expected = "_BaCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Mid_OneElementRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 2, .input = {1}, .expected = {0, 0, 1, 1, 0, 0}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_End_OneElementRange;
+template <> constexpr TestCase<int> FullContainer_End_OneElementRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 5, .input = {-5}, .expected = {11, 29, 35, 14, 84, -5}
+};
+template <> constexpr TestCase<char> FullContainer_End_OneElementRange<char> {
+  .initial = "_BCD_", .index = 5, .input = "a", .expected = "_BCD_a"
+};
+template <> constexpr TestCase<int> FullContainer_End_OneElementRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 5, .input = {1}, .expected = {0, 0, 1, 0, 0, 1}
+};
+
+// Full container / mid-sized range.
+
+template <class T> constexpr TestCase<T> FullContainer_Begin_MidRange;
+template <> constexpr TestCase<int> FullContainer_Begin_MidRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 0,
+  .input = {-5, -3, -1, -7, -9},
+  .expected = {-5, -3, -1, -7, -9, 11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Begin_MidRange<char> {
+  .initial = "_BCD_",
+  .index = 0,
+  .input = "aeiou",
+  .expected = "aeiou_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Begin_MidRange<bool> {
+  .initial = {0, 0, 1, 0, 1},
+  .index = 0,
+  .input = {1, 1, 0, 1, 1},
+  .expected = {1, 1, 0, 1, 1, 0, 0, 1, 0, 1}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_Mid_MidRange;
+template <> constexpr TestCase<int> FullContainer_Mid_MidRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 2,
+  .input = {-5, -3, -1, -7, -9},
+  .expected = {11, 29, -5, -3, -1, -7, -9, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Mid_MidRange<char> {
+  .initial = "_BCD_",
+  .index = 2,
+  .input = "aeiou",
+  .expected = "_BaeiouCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Mid_MidRange<bool> {
+  .initial = {0, 0, 1, 0, 1},
+  .index = 2,
+  .input = {1, 1, 0, 1, 1},
+  .expected = {0, 0, 1, 1, 0, 1, 1, 1, 0, 1}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_End_MidRange;
+template <> constexpr TestCase<int> FullContainer_End_MidRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 5,
+  .input = {-5, -3, -1, -7, -9},
+  .expected = {11, 29, 35, 14, 84, -5, -3, -1, -7, -9}
+};
+template <> constexpr TestCase<char> FullContainer_End_MidRange<char> {
+  .initial = "_BCD_",
+  .index = 5,
+  .input = "aeiou",
+  .expected = "_BCD_aeiou"
+};
+template <> constexpr TestCase<int> FullContainer_End_MidRange<bool> {
+  .initial = {0, 0, 1, 0, 1},
+  .index = 5,
+  .input = {1, 1, 0, 1, 1},
+  .expected = {0, 0, 1, 0, 1, 1, 1, 0, 1, 1}
+};
+
+// Full container / long range.
+
+template <class T> constexpr TestCase<T> FullContainer_Begin_LongRange;
+template <> constexpr TestCase<int> FullContainer_Begin_LongRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 0,
+  .input = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
+  .expected = {
+      -5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48, 11, 29, 35, 14, 84
+  }
+};
+template <> constexpr TestCase<char> FullContainer_Begin_LongRange<char> {
+  .initial = "_BCD_",
+  .index = 0,
+  .input = "aeiouqwxyz5781964203",
+  .expected = "aeiouqwxyz5781964203_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Begin_LongRange<bool> {
+  .initial = {0, 0, 1, 0, 0},
+  .index = 0,
+  .input = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+  .expected = {
+      1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0
+  }
+};
+
+template <class T> constexpr TestCase<T> FullContainer_Mid_LongRange;
+template <> constexpr TestCase<int> FullContainer_Mid_LongRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 2,
+  .input = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
+  .expected = {
+      11, 29, -5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48, 35, 14, 84
+  }
+};
+template <> constexpr TestCase<char> FullContainer_Mid_LongRange<char> {
+  .initial = "_BCD_",
+  .index = 2,
+  .input = "aeiouqwxyz5781964203",
+  .expected = "_Baeiouqwxyz5781964203CD_"
+};
+template <> constexpr TestCase<int> FullContainer_Mid_LongRange<bool> {
+  .initial = {0, 0, 1, 0, 0},
+  .index = 2,
+  .input = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+  .expected = {
+      0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0
+  }
+};
+
+template <class T> constexpr TestCase<T> FullContainer_End_LongRange;
+template <> constexpr TestCase<int> FullContainer_End_LongRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 5,
+  .input = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
+  .expected = {
+      11, 29, 35, 14, 84, -5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48
+  }
+};
+template <> constexpr TestCase<char> FullContainer_End_LongRange<char> {
+  .initial = "_BCD_",
+  .index = 5,
+  .input = "aeiouqwxyz5781964203",
+  .expected = "_BCD_aeiouqwxyz5781964203"
+};
+template <> constexpr TestCase<int> FullContainer_End_LongRange<bool> {
+  .initial = {0, 0, 1, 0, 1},
+  .index = 5,
+  .input = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+  .expected = {
+      0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
+  }
+};
+
+// Sequence containers tests.
+
+template <class Container, class Iter, class Sent, class Validate>
+constexpr void test_sequence_insert_range(Validate validate) {
+  using T = typename Container::value_type;
+  auto get_pos = [](auto& c, auto& test_case) { return std::ranges::next(c.begin(), test_case.index); };
+
+  auto test = [&](auto& test_case) {
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+    auto pos = get_pos(c, test_case);
+
+    auto result = c.insert_range(pos, in);
+    assert(result == get_pos(c, test_case));
+    validate(c);
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty container.
+    // empty_c.insert_range(end, empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.insert_range(end, one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.insert_range(end, mid_range)
+    assert(test(EmptyContainer_MidRange<T>));
+  }
+
+  { // One-element container.
+    // one_element_c.insert_range(begin, empty_range)
+    assert(test(OneElementContainer_Begin_EmptyRange<T>));
+    // one_element_c.insert_range(end, empty_range)
+    assert(test(OneElementContainer_End_EmptyRange<T>));
+    // one_element_c.insert_range(begin, one_element_range)
+    assert(test(OneElementContainer_Begin_OneElementRange<T>));
+    // one_element_c.insert_range(end, one_element_range)
+    assert(test(OneElementContainer_End_OneElementRange<T>));
+    // one_element_c.insert_range(begin, mid_range)
+    assert(test(OneElementContainer_Begin_MidRange<T>));
+    // one_element_c.insert_range(end, mid_range)
+    assert(test(OneElementContainer_End_MidRange<T>));
+  }
+
+  { // Full container.
+    // full_container.insert_range(begin, empty_range)
+    assert(test(FullContainer_Begin_EmptyRange<T>));
+    // full_container.insert_range(mid, empty_range)
+    assert(test(FullContainer_Mid_EmptyRange<T>));
+    // full_container.insert_range(end, empty_range)
+    assert(test(FullContainer_End_EmptyRange<T>));
+    // full_container.insert_range(begin, one_element_range)
+    assert(test(FullContainer_Begin_OneElementRange<T>));
+    // full_container.insert_range(end, one_element_range)
+    assert(test(FullContainer_Mid_OneElementRange<T>));
+    // full_container.insert_range(end, one_element_range)
+    assert(test(FullContainer_End_OneElementRange<T>));
+    // full_container.insert_range(begin, mid_range)
+    assert(test(FullContainer_Begin_MidRange<T>));
+    // full_container.insert_range(mid, mid_range)
+    assert(test(FullContainer_Mid_MidRange<T>));
+    // full_container.insert_range(end, mid_range)
+    assert(test(FullContainer_End_MidRange<T>));
+    // full_container.insert_range(begin, long_range)
+    assert(test(FullContainer_Begin_LongRange<T>));
+    // full_container.insert_range(mid, long_range)
+    assert(test(FullContainer_Mid_LongRange<T>));
+    // full_container.insert_range(end, long_range)
+    assert(test(FullContainer_End_LongRange<T>));
+  }
+}
+
+template <class Container, class Iter, class Sent, class Validate>
+constexpr void test_sequence_prepend_range(Validate validate) {
+  using T = typename Container::value_type;
+
+  auto test = [&](auto& test_case) {
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+
+    c.prepend_range(in);
+    validate(c);
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty container.
+    // empty_c.prepend_range(empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.prepend_range(one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.prepend_range(mid_range)
+    assert(test(EmptyContainer_MidRange<T>));
+  }
+
+  { // One-element container.
+    // one_element_c.prepend_range(empty_range)
+    assert(test(OneElementContainer_Begin_EmptyRange<T>));
+    // one_element_c.prepend_range(one_element_range)
+    assert(test(OneElementContainer_Begin_OneElementRange<T>));
+    // one_element_c.prepend_range(mid_range)
+    assert(test(OneElementContainer_Begin_MidRange<T>));
+  }
+
+  { // Full container.
+    // full_container.prepend_range(empty_range)
+    assert(test(FullContainer_Begin_EmptyRange<T>));
+    // full_container.prepend_range(one_element_range)
+    assert(test(FullContainer_Begin_OneElementRange<T>));
+    // full_container.prepend_range(mid_range)
+    assert(test(FullContainer_Begin_MidRange<T>));
+    // full_container.prepend_range(long_range)
+    assert(test(FullContainer_Begin_LongRange<T>));
+  }
+}
+
+template <class Container, class Iter, class Sent, class Validate>
+constexpr void test_sequence_append_range(Validate validate) {
+  using T = typename Container::value_type;
+
+  auto test = [&](auto& test_case) {
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+
+    c.append_range(in);
+    validate(c);
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty container.
+    // empty_c.append_range(empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.append_range(one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.append_range(mid_range)
+    assert(test(EmptyContainer_MidRange<T>));
+  }
+
+  { // One-element container.
+    // one_element_c.append_range(empty_range)
+    assert(test(OneElementContainer_End_EmptyRange<T>));
+    // one_element_c.append_range(one_element_range)
+    assert(test(OneElementContainer_End_OneElementRange<T>));
+    // one_element_c.append_range(mid_range)
+    assert(test(OneElementContainer_End_MidRange<T>));
+  }
+
+  { // Full container.
+    // full_container.append_range(empty_range)
+    assert(test(FullContainer_End_EmptyRange<T>));
+    // full_container.append_range(one_element_range)
+    assert(test(FullContainer_End_OneElementRange<T>));
+    // full_container.append_range(mid_range)
+    assert(test(FullContainer_End_MidRange<T>));
+    // full_container.append_range(long_range)
+    assert(test(FullContainer_End_LongRange<T>));
+  }
+}
+
+template <class Container, class Iter, class Sent, class Validate>
+constexpr void test_sequence_assign_range(Validate validate) {
+  using T = typename Container::value_type;
+
+  auto& initial_empty = EmptyContainer_EmptyRange<T>.initial;
+  auto& initial_one_element = OneElementContainer_Begin_EmptyRange<T>.initial;
+  auto& initial_full = FullContainer_Begin_EmptyRange<T>.initial;
+  auto& input_empty = FullContainer_Begin_EmptyRange<T>.input;
+  auto& input_one_element = FullContainer_Begin_OneElementRange<T>.input;
+  auto& input_mid_range = FullContainer_Begin_MidRange<T>.input;
+  auto& input_long_range = FullContainer_Begin_LongRange<T>.input;
+
+  auto test = [&](auto& initial, auto& input) {
+    Container c(initial.begin(), initial.end());
+    auto in = wrap_input<Iter, Sent>(input);
+
+    c.assign_range(in);
+    validate(c);
+    return std::ranges::equal(c, input);
+  };
+
+  { // Empty container.
+    // empty_container.assign_range(empty_range)
+    assert(test(initial_empty, input_empty));
+    // empty_container.assign_range(one_element_range)
+    assert(test(initial_empty, input_one_element));
+    // empty_container.assign_range(mid_range)
+    assert(test(initial_empty, input_mid_range));
+    // empty_container.assign_range(long_range)
+    assert(test(initial_empty, input_long_range));
+  }
+
+  { // One-element container.
+    // one_element_container.assign_range(empty_range)
+    assert(test(initial_one_element, input_empty));
+    // one_element_container.assign_range(one_element_range)
+    assert(test(initial_one_element, input_one_element));
+    // one_element_container.assign_range(mid_range)
+    assert(test(initial_one_element, input_mid_range));
+    // one_element_container.assign_range(long_range)
+    assert(test(initial_one_element, input_long_range));
+  }
+
+  { // Full container.
+    // full_container.assign_range(empty_range)
+    assert(test(initial_full, input_empty));
+    // full_container.assign_range(one_element_range)
+    assert(test(initial_full, input_one_element));
+    // full_container.assign_range(mid_range)
+    assert(test(initial_full, input_mid_range));
+    // full_container.assign_range(long_range)
+    assert(test(initial_full, input_long_range));
+  }
+}
+
+// Move-only types.
+
+template <template <class ...> class Container>
+constexpr void test_sequence_insert_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.insert_range(c.end(), in);
+}
+
+template <template <class ...> class Container>
+constexpr void test_sequence_prepend_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.prepend_range(in);
+}
+
+template <template <class ...> class Container>
+constexpr void test_sequence_append_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.append_range(in);
+}
+
+template <template <class ...> class Container>
+constexpr void test_sequence_assign_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.assign_range(in);
+}
+
+// Exception safety.
+
+template <template <class ...> class Container>
+void test_insert_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.insert_range(c.end(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_insert_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(alloc);
+    c.insert_range(c.end(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container>
+void test_prepend_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.prepend_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_prepend_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(alloc);
+    c.prepend_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container>
+void test_append_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.append_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_append_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(alloc);
+    c.append_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container>
+void test_assign_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.assign_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_assign_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(alloc);
+    c.assign_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H
diff --git a/libcxx/test/std/containers/sequences/list/list.cons/deduct.pass.cpp b/libcxx/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
@@ -13,12 +13,16 @@
 //    list(InputIterator, InputIterator, Allocator = Allocator())
 //    -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
+// template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+//   list(from_range_t, R&&, Allocator = Allocator())
+//     -> list<ranges::range_value_t<R>, Allocator>; // C++23
 
-#include <list>
-#include <iterator>
+#include <array>
 #include <cassert>
-#include <cstddef>
 #include <climits> // INT_MAX
+#include <cstddef>
+#include <iterator>
+#include <list>
 
 #include "deduction_guides_sfinae_checks.h"
 #include "test_macros.h"
@@ -127,6 +131,21 @@
         }
     }
 
+#if TEST_STD_VER >= 23
+    {
+      {
+        std::list c(std::from_range, std::array<int, 0>());
+        static_assert(std::is_same_v<decltype(c), std::list<int>>);
+      }
+
+      {
+        using Alloc = test_allocator<int>;
+        std::list c(std::from_range, std::array<int, 0>(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::list<int, Alloc>>);
+      }
+    }
+#endif
+
     SequenceContainerDeductionGuidesSfinaeAway<std::list, std::list<int>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/sequences/list/list.cons/from_range.pass.cpp b/libcxx/test/std/containers/sequences/list/list.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/list/list.cons/from_range.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <list>
+
+#include "../../from_range_sequence_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R>
+//   list(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_container<std::list, int, Iter, Sent, Alloc>([](const auto&) {
+      // No additional validation to do.
+    });
+  });
+  test_sequence_container_move_only<std::list>();
+
+  static_assert(test_constraints<std::list, int, double>());
+
+  test_exception_safety_throwing_copy<std::list>();
+  test_exception_safety_throwing_allocator<std::list, int>();
+
+  return 0;
+}
+
diff --git a/libcxx/test/std/containers/sequences/list/list.modifiers/append_range.pass.cpp b/libcxx/test/std/containers/sequences/list/list.modifiers/append_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/list/list.modifiers/append_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr void append_range(R&& rg); // C++23
+
+#include <list>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (appending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - appending move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_append_range<std::list, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_append_range<std::list<int, Alloc>, Iter, Sent>([](auto&&) {
+      // No additional validation to do.
+    });
+  });
+  test_sequence_append_range_move_only<std::list>();
+
+  test_append_range_exception_safety_throwing_copy<std::list>();
+  test_append_range_exception_safety_throwing_allocator<std::list, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/list/list.modifiers/assign_range.pass.cpp b/libcxx/test/std/containers/sequences/list/list.modifiers/assign_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/list/list.modifiers/assign_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr void assign_range(R&& rg); // C++23
+
+#include <list>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of assignments (assigning an {empty/one-element/mid-sized/long range} to an
+//   {empty/one-element/full} container);
+// - assigning move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_assign_range<std::list, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_assign_range<std::list<int, Alloc>, Iter, Sent>([](auto&&) {
+      // No additional validation to do.
+    });
+  });
+  test_sequence_assign_range_move_only<std::list>();
+
+  test_assign_range_exception_safety_throwing_copy<std::list>();
+  test_assign_range_exception_safety_throwing_allocator<std::list, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/list/list.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/sequences/list/list.modifiers/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/list/list.modifiers/insert_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
+
+#include <list>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (inserting an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container at the {beginning/middle/end});
+// - inserting move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_insert_range<std::list, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range<std::list<int, Alloc>, Iter, Sent>([](auto&&) {
+      // No additional validation to do.
+    });
+  });
+  test_sequence_insert_range_move_only<std::list>();
+
+  test_insert_range_exception_safety_throwing_copy<std::list>();
+  test_insert_range_exception_safety_throwing_allocator<std::list, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/list/list.modifiers/prepend_range.pass.cpp b/libcxx/test/std/containers/sequences/list/list.modifiers/prepend_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/list/list.modifiers/prepend_range.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   constexpr void prepend_range(R&& rg); // C++23
+
+#include <list>
+
+#include "../../insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (prepending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - prepending move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_prepend_range<std::list, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_prepend_range<std::list<int, Alloc>, Iter, Sent>([](auto&&) {
+      // No additional validation to do.
+    });
+  });
+  test_sequence_prepend_range_move_only<std::list>();
+
+  test_prepend_range_exception_safety_throwing_copy<std::list>();
+  test_prepend_range_exception_safety_throwing_allocator<std::list, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/vector.bool/append_range.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/append_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector.bool/append_range.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
+
+// template<container-compatible-range<bool> R>
+//   constexpr void append_range(R&& rg); // C++23
+
+#include <vector>
+
+#include "../insert_range_sequence_containers.h"
+#include "asan_testing.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (appending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - an exception is thrown when allocating new elements.
+constexpr bool test() {
+  static_assert(test_constraints_append_range<std::vector, bool, char>());
+
+  for_all_iterators_and_allocators<bool, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_append_range<std::vector<bool, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+      LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+    });
+  });
+
+  { // Vector may or may not need to reallocate because of the insertion -- make sure to test both cases.
+    { // Ensure reallocation happens.
+      constexpr int N = 255;
+      bool in[N] = {};
+      std::vector<bool> v = {0, 0, 0, 1, 1, 0, 0, 0};
+      auto initial = v;
+      assert(v.capacity() < v.size() + std::ranges::size(in));
+
+      v.append_range(in);
+      // Because `in` is very large (it has to be to exceed the large capacity that `vector<bool>` allocates), it is
+      // impractical to have the expected value as a literal.
+      assert(v.size() == initial.size() + N);
+      assert(std::ranges::equal(v.begin(), v.begin() + initial.size(), initial.begin(), initial.end()));
+      assert(std::ranges::equal(v.begin() + initial.size(), v.end(), std::ranges::begin(in), std::ranges::end(in)));
+    }
+
+    { // Ensure no reallocation happens.
+      bool in[] = {1, 1, 1, 1, 0, 0, 1, 1, 1, 1};
+      std::vector<bool> v = {0, 0, 0, 1, 1, 0, 0, 0};
+      v.reserve(v.size() + std::ranges::size(in));
+      assert(v.capacity() >= v.size() + std::ranges::size(in));
+
+      v.append_range(in);
+      assert(std::ranges::equal(v, std::vector<bool>{0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1}));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  // Note: `test_append_range_exception_safety_throwing_copy` doesn't apply because copying booleans cannot throw.
+  test_append_range_exception_safety_throwing_allocator<std::vector, bool>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/vector.bool/assign_range.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/assign_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector.bool/assign_range.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
+
+// template<container-compatible-range<bool> R>
+//   constexpr void assign_range(R&& rg); // C++23
+
+#include <vector>
+
+#include "../insert_range_sequence_containers.h"
+#include "asan_testing.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of assignments (assigning an {empty/one-element/mid-sized/long range} to an
+//   {empty/one-element/full} container);
+// - an exception is thrown when allocating new elements.
+constexpr bool test() {
+  static_assert(test_constraints_assign_range<std::vector, bool, char>());
+
+  for_all_iterators_and_allocators<bool, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_assign_range<std::vector<bool, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+      LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+    });
+  });
+
+  { // Vector may or may not need to reallocate because of the assignment -- make sure to test both cases.
+    { // Ensure reallocation happens. Note that `vector<bool>` typically reserves a lot of capacity.
+      constexpr int N = 255;
+      bool in[N] = {};
+      std::vector<bool> v = {0, 0, 0, 1, 1, 0, 0, 0};
+      assert(v.capacity() < v.size() + std::ranges::size(in));
+
+      v.assign_range(in);
+      assert(std::ranges::equal(v, in));
+    }
+
+    { // Ensure no reallocation happens.
+      bool in[] = {1, 1, 0, 1, 1};
+      std::vector<bool> v = {0, 0, 0, 1, 1, 0, 0, 0};
+
+      v.assign_range(in);
+      assert(std::ranges::equal(v, in));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  // Note: `test_assign_range_exception_safety_throwing_copy` doesn't apply because copying booleans cannot throw.
+  test_assign_range_exception_safety_throwing_allocator<std::vector, bool>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/vector.bool/construct_from_range.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/construct_from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector.bool/construct_from_range.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <vector>
+
+#include "../from_range_sequence_containers.h"
+#include "asan_testing.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R>
+//   vector(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
+
+constexpr bool test() {
+  for_all_iterators_and_allocators<bool>([]<class Iter, class Sent, class Alloc>() {
+    test_vector_bool<Iter, Sent, Alloc>([](const auto& c) {
+      LIBCPP_ASSERT(c.__invariants());
+      LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+    });
+  });
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  static_assert(test_constraints<std::vector, bool, char>());
+
+  // Note: test_exception_safety_throwing_copy doesn't apply because copying a boolean cannot throw.
+  test_exception_safety_throwing_allocator<std::vector, bool>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/vector.bool/insert_range.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector.bool/insert_range.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
+
+// template<container-compatible-range<bool> R>
+//   constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
+
+#include <vector>
+
+#include "../insert_range_sequence_containers.h"
+#include "asan_testing.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (inserting an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container at the {beginning/middle/end});
+// - an exception is thrown when allocating new elements.
+constexpr bool test() {
+  static_assert(test_constraints_insert_range<std::vector, bool, char>());
+
+  for_all_iterators_and_allocators<bool, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range<std::vector<bool, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+      LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+    });
+  });
+
+  { // Vector may or may not need to reallocate because of the insertion -- make sure to test both cases.
+    { // Ensure reallocation happens.
+      constexpr int N = 255;
+      bool in[N] = {};
+      std::vector<bool> v = {0, 0, 0, 1, 1, 0, 0, 0};
+      auto initial = v;
+      assert(v.capacity() < v.size() + std::ranges::size(in));
+
+      v.insert_range(v.end(), in);
+      // Because `in` is very large (it has to be to exceed the large capacity that `vector<bool>` allocates), it is
+      // impractical to have the expected value as a literal.
+      assert(v.size() == initial.size() + N);
+      assert(std::ranges::equal(v.begin(), v.begin() + initial.size(), initial.begin(), initial.end()));
+      assert(std::ranges::equal(v.begin() + initial.size(), v.end(), std::ranges::begin(in), std::ranges::end(in)));
+    }
+
+    { // Ensure no reallocation happens.
+      bool in[] = {1, 1, 1, 1, 0, 0, 1, 1, 1, 1};
+      std::vector<bool> v = {0, 0, 0, 1, 1, 0, 0, 0};
+      v.reserve(v.size() + std::ranges::size(in));
+      assert(v.capacity() >= v.size() + std::ranges::size(in));
+
+      v.insert_range(v.end(), in);
+      assert(std::ranges::equal(v, std::vector<bool>{0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1}));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  // Note: `test_insert_range_exception_safety_throwing_copy` doesn't apply because copying booleans cannot throw.
+  test_insert_range_exception_safety_throwing_allocator<std::vector, bool>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_from_range.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_from_range.pass.cpp
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<T> R>
+//   vector(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
+
+#include <vector>
+
+#include "../../from_range_sequence_containers.h"
+#include "asan_testing.h"
+#include "test_macros.h"
+
+constexpr bool test() {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_container<std::vector, int, Iter, Sent, Alloc>([](const auto& c) {
+      LIBCPP_ASSERT(c.__invariants());
+      LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+    });
+  });
+  test_sequence_container_move_only<std::vector>();
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test_constraints<std::vector, int, double>());
+  test();
+
+  static_assert(test());
+
+  test_exception_safety_throwing_copy<std::vector>();
+  test_exception_safety_throwing_allocator<std::vector, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
@@ -13,14 +13,18 @@
 //    vector(InputIterator, InputIterator, Allocator = Allocator())
 //    -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
+// 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
 
 #include <algorithm>
-#include <vector>
+#include <array>
 #include <cassert>
-#include <cstddef>
 #include <climits> // INT_MAX
+#include <cstddef>
 #include <iterator>
 #include <type_traits>
+#include <vector>
 
 #include "deduction_guides_sfinae_checks.h"
 #include "test_macros.h"
@@ -94,6 +98,20 @@
     assert(vec.size() == 0);
     }
 
+#if TEST_STD_VER >= 23
+    {
+      {
+        std::vector c(std::from_range, std::array<int, 0>());
+        static_assert(std::is_same_v<decltype(c), std::vector<int>>);
+      }
+
+      {
+        using Alloc = test_allocator<int>;
+        std::vector c(std::from_range, std::array<int, 0>(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::vector<int, Alloc>>);
+      }
+    }
+#endif
 
 //  A couple of vector<bool> tests, too!
     {
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp
@@ -177,6 +177,7 @@
     Allocator<int> alloc(false);
     AllocVec vec(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + 2), alloc);
   } catch (int) {
+    // FIXME: never called.
   }
   check_new_delete_called();
 
@@ -185,6 +186,7 @@
     Allocator<int> alloc(false);
     AllocVec vec(forward_iterator<int*>(a), forward_iterator<int*>(a + 2), alloc);
   } catch (int) {
+    // FIXME: never called.
   }
   check_new_delete_called();
 
diff --git a/libcxx/test/std/containers/sequences/vector/vector.modifiers/append_range.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.modifiers/append_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector/vector.modifiers/append_range.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
+
+// template<container-compatible-range<T> R>
+//   constexpr void append_range(R&& rg); // C++23
+
+#include <vector>
+
+#include "../../insert_range_sequence_containers.h"
+#include "asan_testing.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (appending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - appending move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+constexpr bool test() {
+  static_assert(test_constraints_append_range<std::vector, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_append_range<std::vector<int, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+      LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+    });
+  });
+  test_sequence_append_range_move_only<std::vector>();
+
+  { // Vector may or may not need to reallocate because of the insertion -- make sure to test both cases.
+    { // Ensure reallocation happens.
+      int in[] = {-1, -2, -3, -4, -5, -6, -7, -8, -9, -10};
+      std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8};
+      v.shrink_to_fit();
+      assert(v.capacity() < v.size() + std::ranges::size(in));
+
+      v.append_range(in);
+      assert(std::ranges::equal(v, std::array{1, 2, 3, 4, 5, 6, 7, 8, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10}));
+    }
+
+    { // Ensure no reallocation happens.
+      int in[] = {-1, -2, -3, -4, -5, -6, -7, -8, -9, -10};
+      std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8};
+      v.reserve(v.size() + std::ranges::size(in));
+      assert(v.capacity() >= v.size() + std::ranges::size(in));
+
+      v.append_range(in);
+      assert(std::ranges::equal(v, std::array{1, 2, 3, 4, 5, 6, 7, 8, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10}));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  test_append_range_exception_safety_throwing_copy<std::vector>();
+  test_append_range_exception_safety_throwing_allocator<std::vector, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/vector/vector.modifiers/assign_range.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.modifiers/assign_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector/vector.modifiers/assign_range.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
+
+// template<container-compatible-range<T> R>
+//   constexpr void assign_range(R&& rg); // C++23
+
+#include <vector>
+
+#include "../../insert_range_sequence_containers.h"
+#include "asan_testing.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of assignments (assigning an {empty/one-element/mid-sized/long range} to an
+//   {empty/one-element/full} container);
+// - assigning move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+constexpr bool test() {
+  static_assert(test_constraints_assign_range<std::vector, int, double>());
+
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_assign_range<std::vector<int, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+      LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+    });
+  });
+  test_sequence_assign_range_move_only<std::vector>();
+
+  { // Vector may or may not need to reallocate because of the assignment -- make sure to test both cases.
+    { // Ensure reallocation happens.
+      int in[] = {-1, -2, -3, -4, -5, -6, -7, -8, -9, -10};
+      std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8};
+      v.shrink_to_fit();
+      assert(v.capacity() < v.size() + std::ranges::size(in));
+
+      v.assign_range(in);
+      assert(std::ranges::equal(v, in));
+    }
+
+    { // Ensure no reallocation happens.
+      int in[] = {-1, -2, -3, -4, -5};
+      std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8};
+
+      v.assign_range(in);
+      assert(std::ranges::equal(v, in));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  test_assign_range_exception_safety_throwing_copy<std::vector>();
+  test_assign_range_exception_safety_throwing_allocator<std::vector, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_range.pass.cpp
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
+
+// template<container-compatible-range<T> R>
+//   constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
+
+#include <vector>
+
+#include "../../insert_range_sequence_containers.h"
+#include "asan_testing.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (inserting an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container at the {beginning/middle/end});
+// - inserting move-only elements;
+// - an exception is thrown when copying the elements or when allocating new elements.
+
+constexpr bool test() {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range<std::vector<int, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+      LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+    });
+  });
+  test_sequence_insert_range_move_only<std::vector>();
+
+  { // Vector may or may not need to reallocate because of the insertion -- make sure to test both cases.
+    { // Ensure reallocation happens.
+      int in[] = {-1, -2, -3, -4, -5, -6, -7, -8, -9, -10};
+      std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8};
+      v.shrink_to_fit();
+      assert(v.capacity() < v.size() + std::ranges::size(in));
+
+      v.insert_range(v.end(), in);
+      assert(std::ranges::equal(v, std::array{1, 2, 3, 4, 5, 6, 7, 8, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10}));
+    }
+
+    { // Ensure no reallocation happens.
+      int in[] = {-1, -2, -3, -4, -5, -6, -7, -8, -9, -10};
+      std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8};
+      v.reserve(v.size() + std::ranges::size(in));
+      assert(v.capacity() >= v.size() + std::ranges::size(in));
+
+      v.insert_range(v.end(), in);
+      assert(std::ranges::equal(v, std::array{1, 2, 3, 4, 5, 6, 7, 8, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10}));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  static_assert(test_constraints_insert_range<std::vector, int, double>());
+
+  test_insert_range_exception_safety_throwing_copy<std::vector>();
+  test_insert_range_exception_safety_throwing_allocator<std::vector, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/unord/from_range_unordered_containers.h b/libcxx/test/std/containers/unord/from_range_unordered_containers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/from_range_unordered_containers.h
@@ -0,0 +1,434 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_FROM_RANGE_UNORDERED_CONTAINERS_H
+#define SUPPORT_FROM_RANGE_UNORDERED_CONTAINERS_H
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <ranges>
+#include <vector>
+#include <utility>
+
+#include "../from_range_helpers.h"
+#include "../test_compare.h"
+#include "../test_hash.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   unordered-container(from_range_t, R&& rg, size_type n = see below,
+//     const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+//     const allocator_type& a = allocator_type()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered-container(from_range_t, R&& rg, size_type n, const allocator_type& a)
+//     : unordered-container(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered-container(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+//     : unordered-container(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
+
+template <class Container, class Range>
+concept HasFromRangeCtr = requires (Range&& range) {
+  // (from_range, range)
+  Container(std::from_range, std::forward<Range>(range));
+  // (from_range, range, n)
+  Container(std::from_range, std::forward<Range>(range), 0);
+  // (from_range, range, n, hash)
+  Container(std::from_range, std::forward<Range>(range), 0, std::hash<typename Container::key_type>());
+  // (from_range, range, n, hash, equal)
+  Container(std::from_range, std::forward<Range>(range), 0, std::hash<typename Container::key_type>(),
+            std::equal_to<typename Container::key_type>());
+  // (from_range, range, n, hash, equal, alloc)
+  Container(std::from_range, std::forward<Range>(range), 0, std::hash<typename Container::key_type>(),
+            std::equal_to<typename Container::key_type>(), std::allocator<typename Container::value_type>());
+  // (from_range, range, n, alloc)
+  Container(std::from_range, std::forward<Range>(range), 0, std::allocator<typename Container::value_type>());
+  // (from_range, range, n, hash, alloc)
+  Container(std::from_range, std::forward<Range>(range), 0, std::hash<typename Container::key_type>(),
+            std::allocator<typename Container::value_type>());
+};
+
+template <template <class...> class Container, class K, class V, class K2, class V2>
+constexpr bool test_map_constraints() {
+  using ValueType = std::pair<const K, V>;
+
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<Container<K, V>, InputRange<ValueType>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<Container<K, V>, InputRange<std::pair<const K2, V2>>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<Container<K, V>, InputRange<std::pair<const Empty, V>>>);
+  static_assert(!HasFromRangeCtr<Container<K, V>, InputRange<std::pair<const K, Empty>>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<Container<K, V>, InputRangeNotDerivedFromGeneric<ValueType>>);
+
+  return true;
+}
+
+template <template <class ...> class Container,
+          class K,
+          class V,
+          class Iter,
+          class Sent,
+          class Hash,
+          class Equal,
+          class Alloc,
+          class ValueType = std::pair<const K, V>>
+void test_unordered_map_with_input(std::vector<ValueType>&& input) {
+  using DefaultHash = std::hash<int>;
+  using DefaultEqual = std::equal_to<int>;
+
+  auto validate = [](auto&& c) {
+    if (!c.empty()) {
+      auto diff = c.load_factor() - (static_cast<float>(c.size()) / c.bucket_count());
+      assert(std::fabs(diff) < std::numeric_limits<float>::epsilon());
+    }
+    assert(c.max_load_factor() == 1);
+  };
+
+  auto in = wrap_input<Iter, Sent>(input);
+
+  { // (range)
+    Container<K, V> c(std::from_range, in);
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n)
+    Container<K, V> c(std::from_range, in, 123);
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, hasher)
+    Container<K, V, Hash> c(std::from_range, in, 123, Hash());
+
+    assert(c.hash_function() == Hash());
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, hasher, key_equal)
+    Container<K, V, Hash, Equal> c(std::from_range, in, 123, Hash(), Equal());
+
+    assert(c.hash_function() == Hash());
+    assert(c.key_eq() == Equal());
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, hasher, key_equal, allocator)
+    Alloc alloc;
+    Container<K, V, Hash, Equal, Alloc> c(std::from_range, in, 123, Hash(), Equal(), alloc);
+
+    assert(c.hash_function() == Hash());
+    assert(c.key_eq() == Equal());
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, allocator)
+    Alloc alloc;
+    Container<K, V, DefaultHash, DefaultEqual, Alloc> c(std::from_range, in, 123, alloc);
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, hasher, allocator)
+    Alloc alloc;
+    Container<K, V, Hash, DefaultEqual, Alloc> c(std::from_range, in, 123, Hash(), alloc);
+
+    assert(c.hash_function() == Hash());
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+}
+
+template <template <class ...> class Container,
+          class K,
+          class V,
+          class Iter,
+          class Sent,
+          class Hash,
+          class Equal,
+          class Alloc>
+void test_unordered_map() {
+  auto test_with_input = &test_unordered_map_with_input<Container, K, V, Iter, Sent, Hash, Equal, Alloc>;
+
+  // Normal input.
+  test_with_input({{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}});
+  // Empty input.
+  test_with_input({});
+  // Single-element input.
+  test_with_input({{1, 2}});
+}
+
+template <template <class ...> class Container>
+void test_unordered_map_move_only() {
+  std::pair<const int, MoveOnly> input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  [[maybe_unused]] Container<int, MoveOnly> c(std::from_range, in);
+}
+
+template <template <class ...> class Container>
+void test_map_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using K = int;
+  using V = ThrowingCopy<3>;
+
+  V::throwing_enabled = false;
+  std::pair<const K, V> in[5] = {
+    {1, {}}, {2, {}}, {3, {}}, {4, {}}, {5, {}}
+  };
+  V::throwing_enabled = true;
+  V::reset();
+
+  try {
+    Container<K, V> c(std::from_range, in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(V::created_by_copying == 3);
+    assert(V::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class K, class V>
+void test_map_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using ValueType = std::pair<const K, V>;
+  ValueType in[] = {
+    ValueType{K{1}, V{1}}
+  };
+
+  try {
+    ThrowingAllocator<ValueType> alloc;
+
+    globalMemCounter.reset();
+    Container<K, V, test_hash<K>, test_equal_to<K>, ThrowingAllocator<ValueType>>
+        c(std::from_range, in, /*n=*/0, alloc);
+    assert(false); // The constructor call should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <class Container, class Range>
+concept SetHasFromRangeCtr = requires (Range&& range) {
+  // (from_range, range)
+  Container(std::from_range, std::forward<Range>(range));
+  // (from_range, range, n)
+  Container(std::from_range, std::forward<Range>(range), 0);
+  // (from_range, range, n, hash)
+  Container(std::from_range, std::forward<Range>(range), 0, std::hash<typename Container::value_type>());
+  // (from_range, range, n, hash, equal)
+  Container(std::from_range, std::forward<Range>(range), 0, std::hash<typename Container::value_type>(),
+            std::equal_to<typename Container::value_type>());
+  // (from_range, range, n, hash, equal, alloc)
+  Container(std::from_range, std::forward<Range>(range), 0, std::hash<typename Container::value_type>(),
+            std::equal_to<typename Container::value_type>(), std::allocator<typename Container::value_type>());
+  // (from_range, range, n, alloc)
+  Container(std::from_range, std::forward<Range>(range), 0, std::allocator<typename Container::value_type>());
+  // (from_range, range, n, hash, alloc)
+  Container(std::from_range, std::forward<Range>(range), 0, std::hash<typename Container::value_type>(),
+            std::allocator<typename Container::value_type>());
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_set_constraints() {
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotDerivedFromGeneric<T>>);
+
+  return true;
+}
+
+template <template <class ...> class Container,
+          class T,
+          class Iter,
+          class Sent,
+          class Hash,
+          class Equal,
+          class Alloc>
+void test_unordered_set_with_input(std::vector<T>&& input) {
+  using DefaultHash = std::hash<int>;
+  using DefaultEqual = std::equal_to<int>;
+
+  auto validate = [](auto&& c) {
+    if (!c.empty()) {
+      auto diff = c.load_factor() - (static_cast<float>(c.size()) / c.bucket_count());
+      assert(std::fabs(diff) < std::numeric_limits<float>::epsilon());
+    }
+    assert(c.max_load_factor() == 1);
+  };
+
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    Container<T> c(std::from_range, in);
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n)
+    Container<T> c(std::from_range, in, 123);
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, hasher)
+    Container<T, Hash> c(std::from_range, in, 123, Hash());
+
+    assert(c.hash_function() == Hash());
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, hasher, key_equal)
+    Container<T, Hash, Equal> c(std::from_range, in, 123, Hash(), Equal());
+
+    assert(c.hash_function() == Hash());
+    assert(c.key_eq() == Equal());
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, hasher, key_equal, allocator)
+    Alloc alloc;
+    Container<T, Hash, Equal, Alloc> c(std::from_range, in, 123, Hash(), Equal(), alloc);
+
+    assert(c.hash_function() == Hash());
+    assert(c.key_eq() == Equal());
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, allocator)
+    Alloc alloc;
+    Container<T, DefaultHash, DefaultEqual, Alloc> c(std::from_range, in, 123, alloc);
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+
+  { // (range, n, hasher, allocator)
+    Alloc alloc;
+    Container<T, Hash, DefaultEqual, Alloc> c(std::from_range, in, 123, Hash(), alloc);
+
+    assert(c.hash_function() == Hash());
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    validate(c);
+  }
+}
+
+template <template <class ...> class Container,
+          class T,
+          class Iter,
+          class Sent,
+          class Hash,
+          class Equal,
+          class Alloc>
+void test_unordered_set() {
+  auto test_with_input = &test_unordered_set_with_input<Container, T, Iter, Sent, Hash, Equal, Alloc>;
+
+  // Normal input.
+  test_with_input({0, 5, 12, 7, -1, 8, 26});
+  // Empty input.
+  test_with_input({});
+  // Single-element input.
+  test_with_input({5});
+}
+
+template <template <class ...> class Container>
+void test_unordered_set_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  [[maybe_unused]] Container<MoveOnly> c(std::from_range, in);
+}
+
+template <template <class ...> class Container>
+void test_set_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5] = {{1}, {2}, {3}, {4}, {5}};
+
+  try {
+    Container<T, test_hash<T>> c(std::from_range, in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_set_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {1, 2, 3};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, test_hash<T>, test_equal_to<T>, ThrowingAllocator<T>> c(std::from_range, in, /*n=*/0, alloc);
+    assert(false); // The constructor call should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_FROM_RANGE_UNORDERED_CONTAINERS_H
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp
@@ -54,14 +54,39 @@
 // unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
 //               Allocator)
 //   -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
+//
+// template<ranges::input_range R, class Hash = hash<range-key-type<R>>,
+//           class Pred = equal_to<range-key-type<R>>,
+//           class Allocator = allocator<range-to-alloc-type<R>>>
+//   unordered_map(from_range_t, R&&, typename see below::size_type = see below,
+//                 Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+//     -> unordered_map<range-key-type<R>, range-mapped-type<R>, Hash, Pred, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
+//     -> unordered_map<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+//                       equal_to<range-key-type<R>>, Allocator>;   // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   unordered_map(from_range_t, R&&, Allocator)
+//     -> unordered_map<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+//                       equal_to<range-key-type<R>>, Allocator>;   // C++23
+//
+// template<ranges::input_range R, class Hash, class Allocator>
+//   unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+//     -> unordered_map<range-key-type<R>, range-mapped-type<R>, Hash,
+//                       equal_to<range-key-type<R>>, Allocator>;   // C++23
 
 #include <algorithm> // is_permutation
+#include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <iterator>
 #include <type_traits>
 #include <unordered_map>
 
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
 #include "deduction_guides_sfinae_checks.h"
 #include "test_allocator.h"
 
@@ -220,6 +245,58 @@
     ASSERT_SAME_TYPE(decltype(m2), std::unordered_map<int, int>);
     }
 
+#if TEST_STD_VER >= 23
+    {
+      using Range = std::array<P, 0>;
+      using Pred = test_equal_to<int>;
+      using DefaultPred = std::equal_to<int>;
+      using Hash = test_hash<int>;
+      using DefaultHash = std::hash<int>;
+      using Alloc = test_allocator<PC>;
+
+      { // (from_range, range)
+        std::unordered_map c(std::from_range, Range());
+        static_assert(std::is_same_v<decltype(c), std::unordered_map<int, long>>);
+      }
+
+      { // (from_range, range, n)
+        std::unordered_map c(std::from_range, Range(), std::size_t());
+        static_assert(std::is_same_v<decltype(c), std::unordered_map<int, long>>);
+      }
+
+      { // (from_range, range, n, hash)
+        std::unordered_map c(std::from_range, Range(), std::size_t(), Hash());
+        static_assert(std::is_same_v<decltype(c), std::unordered_map<int, long, Hash>>);
+      }
+
+      { // (from_range, range, n, hash, pred)
+        std::unordered_map c(std::from_range, Range(), std::size_t(), Hash(), Pred());
+        static_assert(std::is_same_v<decltype(c), std::unordered_map<int, long, Hash, Pred>>);
+      }
+
+      { // (from_range, range, n, hash, pred, alloc)
+        std::unordered_map c(std::from_range, Range(), std::size_t(), Hash(), Pred(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_map<int, long, Hash, Pred, Alloc>>);
+      }
+
+      { // (from_range, range, n, alloc)
+        std::unordered_map c(std::from_range, Range(), std::size_t(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_map<int, long, DefaultHash, DefaultPred, Alloc>>);
+      }
+
+      // FIXME -- the constructor doesn't seem to exist.
+      { // (from_range, range, alloc)
+        //std::unordered_map c(std::from_range, Range(), Alloc());
+        //static_assert(std::is_same_v<decltype(c), std::unordered_map<int, long, DefaultHash, DefaultPred, Alloc>>);
+      }
+
+      { // (from_range, range, n, hash, alloc)
+        std::unordered_map c(std::from_range, Range(), std::size_t(), Hash(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_map<int, long, Hash, DefaultPred, Alloc>>);
+      }
+    }
+#endif
+
     UnorderedContainerDeductionGuidesSfinaeAway<std::unordered_map, std::unordered_map<int, long>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/from_range.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/from_range.pass.cpp
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <unordered_map>
+
+#include "../../from_range_unordered_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   unordered_map(from_range_t, R&& rg, size_type n = see below,
+//     const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+//     const allocator_type& a = allocator_type()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
+//     : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+//     : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
+
+void test_duplicates() {
+  using T = std::pair<const int, char>;
+
+  std::array input = {
+    T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{3, 'b'}, T{3, 'c'}, T{2, 'b'}, T{4, 'a'}
+  };
+  std::array expected = {
+    T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{4, 'a'}
+  };
+  auto c = std::unordered_map<int, char>(std::from_range, input);
+  assert(std::ranges::is_permutation(expected, c));
+}
+
+int main(int, char**) {
+  using T = std::pair<const int, int>;
+  for_all_iterators_and_allocators<T>([]<class Iter, class Sent, class Alloc>() {
+    test_unordered_map<std::unordered_map, int, int, Iter, Sent, test_hash<int>, test_equal_to<int>, Alloc>();
+  });
+  test_unordered_map_move_only<std::unordered_map>();
+  test_duplicates();
+
+  static_assert(test_map_constraints<std::unordered_map, int, int, double, double>());
+
+  test_map_exception_safety_throwing_copy<std::unordered_map>();
+  test_map_exception_safety_throwing_allocator<std::unordered_map, int, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_iter_iter.pass.cpp
copy from libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
copy to libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_iter_iter.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
@@ -6,68 +6,33 @@
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_map>
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_map
+// <unordered_map>
 
-// template <class InputIterator>
-//     void insert(InputIterator first, InputIterator last);
+// template<container-compatible-range<value_type> R>
+//   void insert_range(R&& rg); // C++23
 
 #include <unordered_map>
-#include <string>
-#include <cassert>
 
+#include "../../../insert_range_maps_sets.h"
 #include "test_macros.h"
-#include "test_iterators.h"
-#include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::unordered_map<int, std::string> C;
-        typedef std::pair<int, std::string> P;
-        P a[] =
-        {
-            P(1, "one"),
-            P(2, "two"),
-            P(3, "three"),
-            P(4, "four"),
-            P(1, "four"),
-            P(2, "four"),
-        };
-        C c;
-        c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
-        assert(c.size() == 4);
-        assert(c.at(1) == "one");
-        assert(c.at(2) == "two");
-        assert(c.at(3) == "three");
-        assert(c.at(4) == "four");
-    }
-#if TEST_STD_VER >= 11
-    {
-        typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
-                            min_allocator<std::pair<const int, std::string>>> C;
-        typedef std::pair<int, std::string> P;
-        P a[] =
-        {
-            P(1, "one"),
-            P(2, "two"),
-            P(3, "three"),
-            P(4, "four"),
-            P(1, "four"),
-            P(2, "four"),
-        };
-        C c;
-        c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
-        assert(c.size() == 4);
-        assert(c.at(1) == "one");
-        assert(c.at(2) == "two");
-        assert(c.at(3) == "three");
-        assert(c.at(4) == "four");
-    }
-#endif
+int main(int, char**) {
+  // Note: we want to use a pair with non-const elements for input (an assignable type is a lot more convenient) but
+  // have to use the exact `value_type` of the map (that is, `pair<const K, V>`) for the allocator.
+  using Pair = std::pair<int, char>;
+  using ConstPair = std::pair<const int, char>;
+  for_all_iterators_and_allocators<ConstPair, const Pair*>([]<class Iter, class Sent, class Alloc>() {
+    test_map_set_insert_range<std::unordered_map<int, char, test_hash<int>, test_equal_to<int>, Alloc>, Pair, Iter, Sent>();
+  });
+
+  static_assert(test_map_constraints_insert_range<std::unordered_map, int, int, char, double>());
+
+  test_map_insert_range_move_only<std::unordered_map>();
+
+  test_map_insert_range_exception_safety_throwing_copy<std::unordered_map>();
+  test_unord_map_insert_range_exception_safety_throwing_allocator<std::unordered_map, int, int>();
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp
@@ -54,13 +54,38 @@
 // unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
 //                    Allocator)
 //   -> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>;
+//
+// template<ranges::input_range R, class Hash = hash<range-key-type<R>>,
+//           class Pred = equal_to<range-key-type<R>>,
+//           class Allocator = allocator<range-to-alloc-type<R>>>
+//   unordered_multimap(from_range_t, R&&, typename see below::size_type = see below,
+//                 Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+//     -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, Hash, Pred, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   unordered_multimap(from_range_t, R&&, typename see below::size_type, Allocator)
+//     -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+//                       equal_to<range-key-type<R>>, Allocator>;   // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   unordered_multimap(from_range_t, R&&, Allocator)
+//     -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+//                       equal_to<range-key-type<R>>, Allocator>;   // C++23
+//
+// template<ranges::input_range R, class Hash, class Allocator>
+//   unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+//     -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, Hash,
+//                       equal_to<range-key-type<R>>, Allocator>;   // C++23
 
 #include <algorithm> // is_permutation
+#include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <type_traits>
 #include <unordered_map>
 
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
 #include "deduction_guides_sfinae_checks.h"
 #include "test_allocator.h"
 
@@ -219,6 +244,58 @@
     ASSERT_SAME_TYPE(decltype(m2), std::unordered_multimap<int, int>);
     }
 
+#if TEST_STD_VER >= 23
+    {
+      using Range = std::array<P, 0>;
+      using Pred = test_equal_to<int>;
+      using DefaultPred = std::equal_to<int>;
+      using Hash = test_hash<int>;
+      using DefaultHash = std::hash<int>;
+      using Alloc = test_allocator<PC>;
+
+      { // (from_range, range)
+        std::unordered_multimap c(std::from_range, Range());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multimap<int, long>>);
+      }
+
+      { // (from_range, range, n)
+        std::unordered_multimap c(std::from_range, Range(), std::size_t());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multimap<int, long>>);
+      }
+
+      { // (from_range, range, n, hash)
+        std::unordered_multimap c(std::from_range, Range(), std::size_t(), Hash());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multimap<int, long, Hash>>);
+      }
+
+      { // (from_range, range, n, hash, pred)
+        std::unordered_multimap c(std::from_range, Range(), std::size_t(), Hash(), Pred());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multimap<int, long, Hash, Pred>>);
+      }
+
+      { // (from_range, range, n, hash, pred, alloc)
+        std::unordered_multimap c(std::from_range, Range(), std::size_t(), Hash(), Pred(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multimap<int, long, Hash, Pred, Alloc>>);
+      }
+
+      { // (from_range, range, n, alloc)
+        std::unordered_multimap c(std::from_range, Range(), std::size_t(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multimap<int, long, DefaultHash, DefaultPred, Alloc>>);
+      }
+
+      // FIXME -- the constructor doesn't seem to exist.
+      { // (from_range, range, alloc)
+        //std::unordered_multimap c(std::from_range, Range(), Alloc());
+        //static_assert(std::is_same_v<decltype(c), std::unordered_multimap<int, long, DefaultHash, DefaultPred, Alloc>>);
+      }
+
+      { // (from_range, range, n, hash, alloc)
+        std::unordered_multimap c(std::from_range, Range(), std::size_t(), Hash(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multimap<int, long, Hash, DefaultPred, Alloc>>);
+      }
+    }
+#endif
+
     UnorderedContainerDeductionGuidesSfinaeAway<std::unordered_multimap, std::unordered_multimap<int, long>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/from_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/from_range.pass.cpp
@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <unordered_map>
+
+#include "../../from_range_unordered_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   unordered_multimap(from_range_t, R&& rg, size_type n = see below,
+//     const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+//     const allocator_type& a = allocator_type()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
+//     : unordered_multimap(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+//     : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
+
+void test_duplicates() {
+  using T = std::pair<const int, char>;
+  std::array input = {
+    T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{3, 'b'}, T{3, 'c'}, T{2, 'b'}, T{4, 'a'}
+  };
+  auto c = std::unordered_multimap<int, char>(std::from_range, input);
+  assert(std::ranges::is_permutation(input, c));
+}
+
+int main(int, char**) {
+  using T = std::pair<const int, int>;
+  for_all_iterators_and_allocators<T>([]<class Iter, class Sent, class Alloc>() {
+    test_unordered_map<std::unordered_multimap, int, int, Iter, Sent, test_hash<int>, test_equal_to<int>, Alloc>();
+  });
+  test_unordered_map_move_only<std::unordered_multimap>();
+  test_duplicates();
+
+  static_assert(test_map_constraints<std::unordered_multimap, int, int, double, double>());
+
+  test_map_exception_safety_throwing_copy<std::unordered_multimap>();
+  test_map_exception_safety_throwing_allocator<std::unordered_multimap, int, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_iter_iter.pass.cpp
copy from libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
copy to libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_iter_iter.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -6,111 +6,34 @@
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_map>
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_multimap
+// <unordered_map>
 
-// template <class InputIterator>
-//     void insert(InputIterator first, InputIterator last);
+// template<container-compatible-range<value_type> R>
+//   void insert_range(R&& rg); // C++23
 
 #include <unordered_map>
-#include <string>
-#include <set>
-#include <cassert>
-#include <cstddef>
 
+#include "../../../insert_range_maps_sets.h"
 #include "test_macros.h"
-#include "../../../check_consecutive.h"
-#include "test_iterators.h"
-#include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::unordered_multimap<int, std::string> C;
-        typedef std::pair<int, std::string> P;
-        P a[] =
-        {
-            P(1, "one"),
-            P(2, "two"),
-            P(3, "three"),
-            P(4, "four"),
-            P(1, "four"),
-            P(2, "four"),
-        };
-        C c;
-        c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
-        assert(c.size() == 6);
-        typedef std::pair<C::iterator, C::iterator> Eq;
-        Eq eq = c.equal_range(1);
-        assert(std::distance(eq.first, eq.second) == 2);
-        std::multiset<std::string> s;
-        s.insert("one");
-        s.insert("four");
-        CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
-        eq = c.equal_range(2);
-        assert(std::distance(eq.first, eq.second) == 2);
-        s.insert("two");
-        s.insert("four");
-        CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
-        eq = c.equal_range(3);
-        assert(std::distance(eq.first, eq.second) == 1);
-        C::iterator k = eq.first;
-        assert(k->first == 3);
-        assert(k->second == "three");
-        eq = c.equal_range(4);
-        assert(std::distance(eq.first, eq.second) == 1);
-        k = eq.first;
-        assert(k->first == 4);
-        assert(k->second == "four");
-        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
-        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
-    }
-#if TEST_STD_VER >= 11
-    {
-        typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
-                            min_allocator<std::pair<const int, std::string>>> C;
-        typedef std::pair<int, std::string> P;
-        P a[] =
-        {
-            P(1, "one"),
-            P(2, "two"),
-            P(3, "three"),
-            P(4, "four"),
-            P(1, "four"),
-            P(2, "four"),
-        };
-        C c;
-        c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
-        assert(c.size() == 6);
-        typedef std::pair<C::iterator, C::iterator> Eq;
-        Eq eq = c.equal_range(1);
-        assert(std::distance(eq.first, eq.second) == 2);
-        std::multiset<std::string> s;
-        s.insert("one");
-        s.insert("four");
-        CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
-        eq = c.equal_range(2);
-        assert(std::distance(eq.first, eq.second) == 2);
-        s.insert("two");
-        s.insert("four");
-        CheckConsecutiveKeys<C::const_iterator>(c.find(2), c.end(), 2, s);
-        eq = c.equal_range(3);
-        assert(std::distance(eq.first, eq.second) == 1);
-        C::iterator k = eq.first;
-        assert(k->first == 3);
-        assert(k->second == "three");
-        eq = c.equal_range(4);
-        assert(std::distance(eq.first, eq.second) == 1);
-        k = eq.first;
-        assert(k->first == 4);
-        assert(k->second == "four");
-        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
-        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
-    }
-#endif
+int main(int, char**) {
+  // Note: we want to use a pair with non-const elements for input (an assignable type is a lot more convenient) but
+  // have to use the exact `value_type` of the map (that is, `pair<const K, V>`) for the allocator.
+  using Pair = std::pair<int, char>;
+  using ConstPair = std::pair<const int, char>;
+  for_all_iterators_and_allocators<ConstPair, const Pair*>([]<class Iter, class Sent, class Alloc>() {
+    test_map_set_insert_range<std::unordered_multimap<int, char, test_hash<int>, test_equal_to<int>, Alloc>, Pair, Iter, Sent>(/*allow_duplicates=*/true);
+  });
+
+  static_assert(test_map_constraints_insert_range<std::unordered_multimap, int, int, char, double>());
+
+  test_map_insert_range_move_only<std::unordered_multimap>();
+
+  test_map_insert_range_exception_safety_throwing_copy<std::unordered_multimap>();
+  test_unord_map_insert_range_exception_safety_throwing_allocator<std::unordered_multimap, int, int>();
 
   return 0;
 }
+
diff --git a/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/insert_iter_iter.pass.cpp
copy from libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
copy to libcxx/test/std/containers/unord/unord.multiset/insert_iter_iter.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
@@ -6,67 +6,30 @@
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_set>
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
-// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
-//           class Alloc = allocator<Value>>
-// class unordered_multiset
+// <set>
 
-// template <class InputIterator>
-//     void insert(InputIterator first, InputIterator last);
+// template<container-compatible-range<value_type> R>
+//   void insert_range(R&& rg); // C++23
 
 #include <unordered_set>
-#include <cassert>
 
+#include "../../insert_range_maps_sets.h"
 #include "test_macros.h"
-#include "test_iterators.h"
-#include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::unordered_multiset<int> C;
-        typedef int P;
-        P a[] =
-        {
-            P(1),
-            P(2),
-            P(3),
-            P(4),
-            P(1),
-            P(2)
-        };
-        C c;
-        c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
-        assert(c.size() == 6);
-        assert(c.count(1) == 2);
-        assert(c.count(2) == 2);
-        assert(c.count(3) == 1);
-        assert(c.count(4) == 1);
-    }
-#if TEST_STD_VER >= 11
-    {
-        typedef std::unordered_multiset<int, std::hash<int>,
-                                      std::equal_to<int>, min_allocator<int>> C;
-        typedef int P;
-        P a[] =
-        {
-            P(1),
-            P(2),
-            P(3),
-            P(4),
-            P(1),
-            P(2)
-        };
-        C c;
-        c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
-        assert(c.size() == 6);
-        assert(c.count(1) == 2);
-        assert(c.count(2) == 2);
-        assert(c.count(3) == 1);
-        assert(c.count(4) == 1);
-    }
-#endif
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_map_set_insert_range<std::unordered_multiset<int, test_hash<int>, test_equal_to<int>, Alloc>, int, Iter, Sent>(/*allow_duplicates=*/true);
+  });
+
+  static_assert(test_set_constraints_insert_range<std::unordered_multiset, int, double>());
+
+  test_set_insert_range_move_only<std::unordered_multiset>();
+
+  test_set_insert_range_exception_safety_throwing_copy<std::unordered_multiset>();
+  test_unord_set_insert_range_exception_safety_throwing_allocator<std::unordered_multiset, int>();
 
   return 0;
 }
+
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp
@@ -46,13 +46,38 @@
 // template<class T, class Hash, class Allocator>
 // unordered_multiset(initializer_list<T>, typename see below::size_type, Hash, Allocator)
 //   -> unordered_multiset<T, Hash, equal_to<T>, Allocator>;
+//
+// template<ranges::input_range R,
+//          class Hash = hash<ranges::range_value_t<R>>,
+//          class Pred = equal_to<ranges::range_value_t<R>>,
+//          class Allocator = allocator<ranges::range_value_t<R>>>
+//   unordered_multiset(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+//     -> unordered_multiset<ranges::range_value_t<R>, Hash, Pred, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   unordered_multiset(from_range_t, R&&, typename see below::size_type, Allocator)
+//     -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+//                       equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   unordered_multiset(from_range_t, R&&, Allocator)
+//     -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+//                       equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Hash, class Allocator>
+//   unordered_multiset(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+//     -> unordered_multiset<ranges::range_value_t<R>, Hash,
+//                       equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
 
 #include <algorithm> // is_permutation
+#include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <type_traits>
 #include <unordered_set>
 
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
 #include "deduction_guides_sfinae_checks.h"
 #include "test_allocator.h"
 
@@ -193,6 +218,57 @@
     assert(s.get_allocator().get_id() == 42);
     }
 
+#if TEST_STD_VER >= 23
+    {
+      using Range = std::array<int, 0>;
+      using Pred = test_equal_to<int>;
+      using DefaultPred = std::equal_to<int>;
+      using Hash = test_hash<int>;
+      using DefaultHash = std::hash<int>;
+      using Alloc = test_allocator<int>;
+
+      { // (from_range, range)
+        std::unordered_multiset c(std::from_range, Range());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multiset<int>>);
+      }
+
+      { // (from_range, range, n)
+        std::unordered_multiset c(std::from_range, Range(), std::size_t());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multiset<int>>);
+      }
+
+      { // (from_range, range, n, hash)
+        std::unordered_multiset c(std::from_range, Range(), std::size_t(), Hash());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multiset<int, Hash>>);
+      }
+
+      { // (from_range, range, n, hash, pred)
+        std::unordered_multiset c(std::from_range, Range(), std::size_t(), Hash(), Pred());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multiset<int, Hash, Pred>>);
+      }
+
+      { // (from_range, range, n, hash, pred, alloc)
+        std::unordered_multiset c(std::from_range, Range(), std::size_t(), Hash(), Pred(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multiset<int, Hash, Pred, Alloc>>);
+      }
+
+      { // (from_range, range, n, alloc)
+        std::unordered_multiset c(std::from_range, Range(), std::size_t(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multiset<int, DefaultHash, DefaultPred, Alloc>>);
+      }
+
+      // FIXME -- the constructor doesn't seem to exist.
+      { // (from_range, range, alloc)
+        //std::unordered_multiset c(std::from_range, Range(), Alloc());
+        //static_assert(std::is_same_v<decltype(c), std::unordered_multiset<int, DefaultHash, DefaultPred, Alloc>>);
+      }
+
+      { // (from_range, range, n, hash, alloc)
+        std::unordered_multiset c(std::from_range, Range(), std::size_t(), Hash(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_multiset<int, Hash, DefaultPred, Alloc>>);
+      }
+    }
+#endif
     UnorderedContainerDeductionGuidesSfinaeAway<std::unordered_multiset, std::unordered_multiset<int>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/from_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/from_range.pass.cpp
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <unordered_set>
+
+#include "../../from_range_unordered_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   unordered_multiset(from_range_t, R&& rg, size_type n = see below,
+//     const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+//     const allocator_type& a = allocator_type()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a)
+//     : unordered_multiset(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+//     : unordered_multiset(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
+
+void test_duplicates() {
+  std::array input = {1, 2, 3, 3, 3, 4, 2, 1, 2};
+  auto c = std::unordered_multiset<int>(std::from_range, input);
+  assert(std::ranges::is_permutation(input, c));
+}
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_unordered_set<std::unordered_multiset, int, Iter, Sent, test_hash<int>, test_equal_to<int>, Alloc>();
+  });
+  test_unordered_set_move_only<std::unordered_multiset>();
+
+  static_assert(test_set_constraints<std::unordered_set, int, double>());
+
+  test_set_exception_safety_throwing_copy<std::unordered_multiset>();
+  test_set_exception_safety_throwing_allocator<std::unordered_multiset, int>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.set/insert_iter_iter.pass.cpp
copy from libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
copy to libcxx/test/std/containers/unord/unord.set/insert_iter_iter.pass.cpp
diff --git a/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
@@ -6,67 +6,29 @@
 //
 //===----------------------------------------------------------------------===//
 
-// <unordered_set>
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
-// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
-//           class Alloc = allocator<Value>>
-// class unordered_set
+// <set>
 
-// template <class InputIterator>
-//     void insert(InputIterator first, InputIterator last);
+// template<container-compatible-range<value_type> R>
+//   void insert_range(R&& rg); // C++23
 
 #include <unordered_set>
-#include <cassert>
 
+#include "../../insert_range_maps_sets.h"
 #include "test_macros.h"
-#include "test_iterators.h"
-#include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::unordered_set<int> C;
-        typedef int P;
-        P a[] =
-        {
-            P(1),
-            P(2),
-            P(3),
-            P(4),
-            P(1),
-            P(2)
-        };
-        C c;
-        c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
-        assert(c.size() == 4);
-        assert(c.count(1) == 1);
-        assert(c.count(2) == 1);
-        assert(c.count(3) == 1);
-        assert(c.count(4) == 1);
-    }
-#if TEST_STD_VER >= 11
-    {
-        typedef std::unordered_set<int, std::hash<int>,
-                                      std::equal_to<int>, min_allocator<int>> C;
-        typedef int P;
-        P a[] =
-        {
-            P(1),
-            P(2),
-            P(3),
-            P(4),
-            P(1),
-            P(2)
-        };
-        C c;
-        c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
-        assert(c.size() == 4);
-        assert(c.count(1) == 1);
-        assert(c.count(2) == 1);
-        assert(c.count(3) == 1);
-        assert(c.count(4) == 1);
-    }
-#endif
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_map_set_insert_range<std::unordered_set<int, test_hash<int>, test_equal_to<int>, Alloc>, int, Iter, Sent>();
+  });
+
+  static_assert(test_set_constraints_insert_range<std::unordered_set, int, double>());
+
+  test_set_insert_range_move_only<std::unordered_set>();
+
+  test_set_insert_range_exception_safety_throwing_copy<std::unordered_set>();
+  test_unord_set_insert_range_exception_safety_throwing_allocator<std::unordered_set, int>();
 
   return 0;
 }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp
@@ -46,13 +46,38 @@
 // template<class T, class Hash, class Allocator>
 // unordered_set(initializer_list<T>, typename see below::size_type, Hash, Allocator)
 //   -> unordered_set<T, Hash, equal_to<T>, Allocator>;
+//
+// template<ranges::input_range R,
+//          class Hash = hash<ranges::range_value_t<R>>,
+//          class Pred = equal_to<ranges::range_value_t<R>>,
+//          class Allocator = allocator<ranges::range_value_t<R>>>
+//   unordered_set(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+//     -> unordered_set<ranges::range_value_t<R>, Hash, Pred, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   unordered_set(from_range_t, R&&, typename see below::size_type, Allocator)
+//     -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+//                       equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   unordered_set(from_range_t, R&&, Allocator)
+//     -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+//                       equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+//
+// template<ranges::input_range R, class Hash, class Allocator>
+//   unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+//     -> unordered_set<ranges::range_value_t<R>, Hash,
+//                       equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
 
 #include <algorithm> // is_permutation
+#include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <type_traits>
 #include <unordered_set>
 
+#include "../../../test_compare.h"
+#include "../../../test_hash.h"
 #include "deduction_guides_sfinae_checks.h"
 #include "test_allocator.h"
 
@@ -193,6 +218,58 @@
     assert(s.get_allocator().get_id() == 42);
     }
 
+#if TEST_STD_VER >= 23
+    {
+      using Range = std::array<int, 0>;
+      using Pred = test_equal_to<int>;
+      using DefaultPred = std::equal_to<int>;
+      using Hash = test_hash<int>;
+      using DefaultHash = std::hash<int>;
+      using Alloc = test_allocator<int>;
+
+      { // (from_range, range)
+        std::unordered_set c(std::from_range, Range());
+        static_assert(std::is_same_v<decltype(c), std::unordered_set<int>>);
+      }
+
+      { // (from_range, range, n)
+        std::unordered_set c(std::from_range, Range(), std::size_t());
+        static_assert(std::is_same_v<decltype(c), std::unordered_set<int>>);
+      }
+
+      { // (from_range, range, n, hash)
+        std::unordered_set c(std::from_range, Range(), std::size_t(), Hash());
+        static_assert(std::is_same_v<decltype(c), std::unordered_set<int, Hash>>);
+      }
+
+      { // (from_range, range, n, hash, pred)
+        std::unordered_set c(std::from_range, Range(), std::size_t(), Hash(), Pred());
+        static_assert(std::is_same_v<decltype(c), std::unordered_set<int, Hash, Pred>>);
+      }
+
+      { // (from_range, range, n, hash, pred, alloc)
+        std::unordered_set c(std::from_range, Range(), std::size_t(), Hash(), Pred(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_set<int, Hash, Pred, Alloc>>);
+      }
+
+      { // (from_range, range, n, alloc)
+        std::unordered_set c(std::from_range, Range(), std::size_t(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_set<int, DefaultHash, DefaultPred, Alloc>>);
+      }
+
+      // FIXME -- the constructor doesn't seem to exist.
+      { // (from_range, range, alloc)
+        //std::unordered_set c(std::from_range, Range(), Alloc());
+        //static_assert(std::is_same_v<decltype(c), std::unordered_set<int, DefaultHash, DefaultPred, Alloc>>);
+      }
+
+      { // (from_range, range, n, hash, alloc)
+        std::unordered_set c(std::from_range, Range(), std::size_t(), Hash(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::unordered_set<int, Hash, DefaultPred, Alloc>>);
+      }
+    }
+#endif
+
     UnorderedContainerDeductionGuidesSfinaeAway<std::unordered_set, std::unordered_set<int>>();
 
     return 0;
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/from_range.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/from_range.pass.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <unordered_set>
+
+#include "../../from_range_unordered_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<value_type> R>
+//   unordered_set(from_range_t, R&& rg, size_type n = see below,
+//     const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+//     const allocator_type& a = allocator_type()); // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
+//     : unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+//
+// template<container-compatible-range<value_type> R>
+//   unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+//     : unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
+
+void test_duplicates() {
+  using T = KeyValue;
+
+  std::array input = {
+    T{1, 'a'}, T{2, 'a'}, T{3, 'a'}, T{3, 'b'}, T{3, 'c'}, T{2, 'b'}, T{4, 'a'}
+  };
+  std::array expected = {
+    T{1, 'a'}, T{2, 'b'}, T{3, 'c'}, T{4, 'a'}
+  };
+  auto c = std::unordered_set<T>(std::from_range, input);
+  assert(std::ranges::is_permutation(expected, c));
+}
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_unordered_set<std::unordered_set, int, Iter, Sent, test_hash<int>, test_equal_to<int>, Alloc>();
+  });
+  test_unordered_set_move_only<std::unordered_set>();
+  test_duplicates();
+
+  static_assert(test_set_constraints<std::unordered_set, int, double>());
+
+  test_set_exception_safety_throwing_copy<std::unordered_set>();
+  test_set_exception_safety_throwing_allocator<std::unordered_set, int>();
+
+  return 0;
+}
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/forward_list.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/forward_list.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/forward_list.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/forward_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/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/map.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/map.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/map.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/map.version.compile.pass.cpp
@@ -258,17 +258,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/queue.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/queue.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/queue.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/queue.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/ranges.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.compile.pass.cpp
@@ -15,14 +15,15 @@
 
 // Test the feature test macros defined by <ranges>
 
-/*  Constant                      Value
-    __cpp_lib_ranges              202106L [C++20]
-    __cpp_lib_ranges_as_rvalue    202207L [C++2b]
-    __cpp_lib_ranges_chunk        202202L [C++2b]
-    __cpp_lib_ranges_chunk_by     202202L [C++2b]
-    __cpp_lib_ranges_join_with    202202L [C++2b]
-    __cpp_lib_ranges_slide        202202L [C++2b]
-    __cpp_lib_ranges_zip          202110L [C++2b]
+/*  Constant                         Value
+    __cpp_lib_ranges                 202106L [C++20]
+    __cpp_lib_ranges_as_rvalue       202207L [C++2b]
+    __cpp_lib_ranges_chunk           202202L [C++2b]
+    __cpp_lib_ranges_chunk_by        202202L [C++2b]
+    __cpp_lib_ranges_join_with       202202L [C++2b]
+    __cpp_lib_ranges_slide           202202L [C++2b]
+    __cpp_lib_ranges_to_container    202202L [C++2b]
+    __cpp_lib_ranges_zip             202110L [C++2b]
 */
 
 #include <ranges>
@@ -54,6 +55,10 @@
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
@@ -84,6 +89,10 @@
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
@@ -114,6 +123,10 @@
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
@@ -147,6 +160,10 @@
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_to_container
+#   error "__cpp_lib_ranges_to_container should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
@@ -219,6 +236,13 @@
 #   endif
 # 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)
 #   ifndef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should be defined in c++2b"
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/set.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/set.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/set.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/set.version.compile.pass.cpp
@@ -228,17 +228,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/unordered_set.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/unordered_set.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/unordered_set.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/unordered_set.version.compile.pass.cpp
@@ -222,17 +222,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/vector.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/vector.version.compile.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/vector.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/vector.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/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
@@ -4682,17 +4682,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/from_range_t.compile.pass.cpp b/libcxx/test/std/ranges/range.utility/range.utility.conv/from_range_t.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.utility/range.utility.conv/from_range_t.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// struct from_range_t { explicit from_range_t() = default; };  // Since C++23
+// inline constexpr from_range_t from_range{};                  // Since C++23
+
+#include <ranges>
+
+template <class T>
+void check(std::from_range_t);
+
+template <class T>
+concept IsCtrNonexplicit = requires {
+  check<T>({});
+};
+
+// Verify that the constructor is `explicit`.
+static_assert(!IsCtrNonexplicit<std::from_range_t>);
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,816 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// TODO(varconst): the Clang bug (causing trouble with constraints in classes like `ContainerWithDirectCtr`) is fixed in
+// trunk -- `clang-17` should be removed from the failing list once that version of Clang is in the Docker image.
+// XFAIL: clang-16, clang-17
+
+// 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 <array>
+#include <cassert>
+#include <vector>
+#include "test_iterators.h"
+#include "test_range.h"
+
+template <class Container, class Range, class... Args>
+concept HasTo = requires (Range&& range, Args ...args) {
+  std::ranges::to<Container>(std::forward<Range>(range), std::forward<Args>(args)...);
+};
+
+struct InputRange {
+  int x = 0;
+  constexpr cpp20_input_iterator<int*> begin() {
+    return cpp20_input_iterator<int*>(&x);
+  }
+  constexpr sentinel_wrapper<cpp20_input_iterator<int*>> end() {
+    return sentinel_wrapper<cpp20_input_iterator<int*>>(begin());
+  }
+};
+static_assert(std::ranges::input_range<InputRange>);
+
+struct common_cpp20_input_iterator {
+  using value_type = int;
+  using difference_type = long long;
+  using iterator_concept = std::input_iterator_tag;
+  // Deliberately not defining `iterator_category` to make sure this class satisfies the `input_iterator` concept but
+  // would fail `derived_from<iterator_category, input_iterator_tag`.
+
+  int x = 0;
+
+  // Copyable so that it can be used as a sentinel against itself.
+  constexpr decltype(auto) operator*() const { return x; }
+  constexpr common_cpp20_input_iterator& operator++() { return *this; }
+  constexpr void operator++(int) {}
+  constexpr friend bool operator==(common_cpp20_input_iterator, common_cpp20_input_iterator) { return true; }
+};
+static_assert(std::input_iterator<common_cpp20_input_iterator>);
+static_assert(std::sentinel_for<common_cpp20_input_iterator, common_cpp20_input_iterator>);
+template <class T>
+concept HasIteratorCategory = requires {
+  typename std::iterator_traits<T>::iterator_category;
+};
+static_assert(!HasIteratorCategory<common_cpp20_input_iterator>);
+
+struct CommonInputRange {
+  int x = 0;
+  constexpr common_cpp20_input_iterator begin() { return {}; }
+  constexpr common_cpp20_input_iterator end() { return begin(); }
+};
+static_assert(std::ranges::input_range<CommonInputRange>);
+static_assert(std::ranges::common_range<CommonInputRange>);
+
+struct CommonRange {
+  int x = 0;
+  constexpr forward_iterator<int*> begin() {
+    return forward_iterator<int*>(&x);
+  }
+  constexpr forward_iterator<int*> end() {
+    return begin();
+  }
+};
+static_assert(std::ranges::input_range<CommonRange>);
+static_assert(std::ranges::common_range<CommonRange>);
+
+struct NonCommonRange {
+  int x = 0;
+  constexpr forward_iterator<int*> begin() {
+    return forward_iterator<int*>(&x);
+  }
+  constexpr sentinel_wrapper<forward_iterator<int*>> end() {
+    return sentinel_wrapper<forward_iterator<int*>>(begin());
+  }
+};
+static_assert(std::ranges::input_range<NonCommonRange>);
+static_assert(!std::ranges::common_range<NonCommonRange>);
+static_assert(std::derived_from<
+    typename std::iterator_traits<std::ranges::iterator_t<NonCommonRange>>::iterator_category,
+    std::input_iterator_tag>);
+
+using ContainerT = int;
+static_assert(!std::ranges::view<ContainerT>);
+static_assert(HasTo<ContainerT, InputRange>);
+static_assert(!HasTo<test_view<forward_iterator>, InputRange>);
+
+// Note: it's not possible to check the `input_range` constraint because if it's not satisfied, the pipe adaptor
+// overload hijacks the call (it takes unconstrained variadic arguments).
+
+// Check the exact constraints for each one of the cases inside `ranges::to`.
+
+enum class CtrChoice {
+  Invalid,
+  DefaultCtrAndInsert,
+  BeginEndPair,
+  FromRangeT,
+  DirectCtr
+};
+
+enum class InserterChoice {
+  Invalid,
+  Insert,
+  PushBack
+};
+
+struct Empty {};
+
+struct Fallback {
+  using value_type = int;
+
+  CtrChoice ctr_choice = CtrChoice::Invalid;
+  int x = 0;
+
+  constexpr Fallback() : ctr_choice(CtrChoice::DefaultCtrAndInsert) {}
+  constexpr Fallback(Empty) : ctr_choice(CtrChoice::DefaultCtrAndInsert) {}
+
+  constexpr void push_back(value_type) {}
+  constexpr value_type* begin() { return &x; }
+  constexpr value_type* end() { return &x; }
+};
+
+struct CtrDirectOrFallback : Fallback {
+  using Fallback::Fallback;
+  constexpr CtrDirectOrFallback(InputRange&&, int = 0) { ctr_choice = CtrChoice::DirectCtr; }
+};
+
+struct CtrFromRangeTOrFallback : Fallback {
+  using Fallback::Fallback;
+  constexpr CtrFromRangeTOrFallback(std::from_range_t, InputRange&&, int = 0) { ctr_choice = CtrChoice::FromRangeT; }
+};
+
+struct CtrBeginEndPairOrFallback : Fallback {
+  using Fallback::Fallback;
+  template <class Iter>
+  constexpr CtrBeginEndPairOrFallback(Iter, Iter, int = 0) { ctr_choice = CtrChoice::BeginEndPair; }
+};
+
+template <bool HasSize>
+struct MaybeSizedRange {
+  int x = 0;
+  constexpr forward_iterator<int*> begin() { return forward_iterator<int*>(&x); }
+  constexpr forward_iterator<int*> end() { return begin(); }
+
+  constexpr std::size_t size() const
+  requires HasSize {
+    return 0;
+  }
+};
+static_assert(std::ranges::sized_range<MaybeSizedRange<true>>);
+static_assert(!std::ranges::sized_range<MaybeSizedRange<false>>);
+
+template <bool HasCapacity = true, bool CapacityReturnsSizeT = true,
+          bool HasMaxSize = true, bool MaxSizeReturnsSizeT = true>
+struct Reservable : Fallback {
+  bool reserve_called = false;
+
+  using Fallback::Fallback;
+
+  constexpr std::size_t capacity() const
+  requires (HasCapacity && CapacityReturnsSizeT) {
+    return 0;
+  }
+  constexpr int capacity() const
+  requires (HasCapacity && !CapacityReturnsSizeT) {
+    return 0;
+  }
+
+  constexpr std::size_t max_size() const
+  requires (HasMaxSize && MaxSizeReturnsSizeT) {
+    return 0;
+  }
+  constexpr int max_size() const
+  requires (HasMaxSize && !MaxSizeReturnsSizeT) {
+    return 0;
+  }
+
+  constexpr void reserve(std::size_t) {
+    reserve_called = true;
+  }
+};
+static_assert(std::ranges::__reservable_container<Reservable<>>);
+
+constexpr void test_constraints() {
+  { // Case 1 -- construct directly from the range.
+    { // (range)
+      auto result = std::ranges::to<CtrDirectOrFallback>(InputRange());
+      assert(result.ctr_choice == CtrChoice::DirectCtr);
+    }
+
+    { // (range, arg)
+      auto result = std::ranges::to<CtrDirectOrFallback>(InputRange(), 1);
+      assert(result.ctr_choice == CtrChoice::DirectCtr);
+    }
+
+    { // (range, convertible-to-arg)
+      auto result = std::ranges::to<CtrDirectOrFallback>(InputRange(), 1.0);
+      assert(result.ctr_choice == CtrChoice::DirectCtr);
+    }
+
+    { // (range, BAD_arg)
+      auto result = std::ranges::to<CtrDirectOrFallback>(InputRange(), Empty());
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+    }
+  }
+
+  { // Case 2 -- construct using the `from_range_t` tagged constructor.
+    { // (range)
+      auto result = std::ranges::to<CtrFromRangeTOrFallback>(InputRange());
+      assert(result.ctr_choice == CtrChoice::FromRangeT);
+    }
+
+    { // (range, arg)
+      auto result = std::ranges::to<CtrFromRangeTOrFallback>(InputRange(), 1);
+      assert(result.ctr_choice == CtrChoice::FromRangeT);
+    }
+
+    { // (range, convertible-to-arg)
+      auto result = std::ranges::to<CtrFromRangeTOrFallback>(InputRange(), 1.0);
+      assert(result.ctr_choice == CtrChoice::FromRangeT);
+    }
+
+    { // (range, BAD_arg)
+      auto result = std::ranges::to<CtrFromRangeTOrFallback>(InputRange(), Empty());
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+    }
+  }
+
+  { // Case 3 -- construct from a begin-end iterator pair.
+    { // (range)
+      auto result = std::ranges::to<CtrBeginEndPairOrFallback>(CommonRange());
+      assert(result.ctr_choice == CtrChoice::BeginEndPair);
+    }
+
+    { // (range, arg)
+      auto result = std::ranges::to<CtrBeginEndPairOrFallback>(CommonRange(), 1);
+      assert(result.ctr_choice == CtrChoice::BeginEndPair);
+    }
+
+    { // (range, convertible-to-arg)
+      auto result = std::ranges::to<CtrBeginEndPairOrFallback>(CommonRange(), 1.0);
+      assert(result.ctr_choice == CtrChoice::BeginEndPair);
+    }
+
+    { // (BAD_range) -- not a common range.
+      auto result = std::ranges::to<CtrBeginEndPairOrFallback>(NonCommonRange());
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+    }
+
+    { // (BAD_range) -- iterator type not derived from `input_iterator_tag`.
+      auto result = std::ranges::to<CtrBeginEndPairOrFallback>(CommonInputRange());
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+    }
+
+    { // (range, BAD_arg)
+      auto result = std::ranges::to<CtrBeginEndPairOrFallback>(CommonRange(), Empty());
+      assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+    }
+  }
+
+  { // Case 4 -- default-construct (or construct from the extra arguments) and insert, reserving the size if possible.
+    // Note: it's not possible to check the constraints on the default constructor using this approach because there is
+    // nothing to fall back to -- the call will result in a hard error.
+    // However, it's possible to check the constraints on reserving the capacity.
+
+    { // All constraints satisfied.
+      using C = Reservable<>;
+      auto result = std::ranges::to<C>(MaybeSizedRange<true>());
+      assert(result.reserve_called);
+    }
+
+    { // !sized_range
+      using C = Reservable<>;
+      auto result = std::ranges::to<C>(MaybeSizedRange<false>());
+      assert(!result.reserve_called);
+    }
+
+    { // Missing `capacity`.
+      using C = Reservable</*HasCapacity=*/false>;
+      auto result = std::ranges::to<C>(MaybeSizedRange<true>());
+      assert(!result.reserve_called);
+    }
+
+    { // `capacity` doesn't return `size_type`.
+      using C = Reservable</*HasCapacity=*/true, /*CapacityReturnsSizeT=*/false>;
+      auto result = std::ranges::to<C>(MaybeSizedRange<true>());
+      assert(!result.reserve_called);
+    }
+
+    { // Missing `max_size`.
+      using C = Reservable</*HasCapacity=*/true, /*CapacityReturnsSizeT=*/true, /*HasMaxSize=*/false>;
+      auto result = std::ranges::to<C>(MaybeSizedRange<true>());
+      assert(!result.reserve_called);
+    }
+
+    { // `max_size` doesn't return `size_type`.
+      using C = Reservable<
+        /*HasCapacity=*/true, /*CapacityReturnsSizeT=*/true, /*HasMaxSize=*/true, /*MaxSizeReturnsSizeT=*/false>;
+      auto result = std::ranges::to<C>(MaybeSizedRange<true>());
+      assert(!result.reserve_called);
+    }
+  }
+}
+
+// Allows checking that `ranges::to` correctly follows the order of priority of different constructors -- e.g., if
+// 3 constructors are available, the `from_range_t` constructor is chosen in favor of the constructor taking two
+// iterators, etc.
+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());
+  }
+
+  // Check that `ranges::to` can also pass extra parameters.
+  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 std::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) {
+    assert(size() + 1 <= Capacity);
+
+    inserter_choice = InserterChoice::Insert;
+
+    std::shift_right(where, end(), 1);
+    *where = val;
+    ++size_;
+
+    return where;
+  }
+
+  constexpr void reserve(size_t)
+  requires CanReserve {
+    called_reserve = true;
+  }
+
+  constexpr std::size_t capacity() const
+  requires CanReserve {
+    return Capacity;
+  }
+
+  constexpr std::size_t max_size() const
+  requires CanReserve {
+    return Capacity;
+  }
+
+  friend constexpr bool operator==(const Container&, const Container&) = default;
+};
+
+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));
+      assert((in | std::ranges::to<C>()) == result);
+      auto closure = std::ranges::to<C>();
+      assert((in | closure) == result);
+    }
+
+    { // 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);
+      assert((in | std::ranges::to<C>(arg1, arg2)) == result);
+      auto closure = std::ranges::to<C>(arg1, arg2);
+      assert((in | closure) == result);
+    }
+  }
+
+  { // 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));
+      assert((in | std::ranges::to<C>()) == result);
+      auto closure = std::ranges::to<C>();
+      assert((in | closure) == result);
+    }
+
+    { // 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);
+      assert((in | std::ranges::to<C>(arg1, arg2)) == result);
+      auto closure = std::ranges::to<C>(arg1, arg2);
+      assert((in | closure) == result);
+    }
+  }
+
+  { // 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));
+      assert((in | std::ranges::to<C>()) == result);
+      auto closure = std::ranges::to<C>();
+      assert((in | closure) == result);
+    }
+
+    { // 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);
+      assert((in | std::ranges::to<C>(arg1, arg2)) == result);
+      auto closure = std::ranges::to<C>(arg1, arg2);
+      assert((in | closure) == result);
+    }
+  }
+
+  { // 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);
+      assert((in | std::ranges::to<C>()) == result);
+      auto closure = std::ranges::to<C>();
+      assert((in | closure) == result);
+    }
+
+    {
+      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);
+      assert((in | std::ranges::to<C>()) == result);
+      auto closure = std::ranges::to<C>();
+      assert((in | closure) == result);
+    }
+
+    {
+      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);
+      assert((in | std::ranges::to<C>()) == result);
+      auto closure = std::ranges::to<C>();
+      assert((in | closure) == result);
+    }
+
+    {
+      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);
+      assert((in | std::ranges::to<C>()) == result);
+      auto closure = std::ranges::to<C>();
+      assert((in | closure) == result);
+    }
+
+    { // 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);
+      assert((in | std::ranges::to<C>(arg1, arg2)) == result);
+      auto closure = std::ranges::to<C>(arg1, arg2);
+      assert((in | closure) == result);
+    }
+  }
+}
+
+template <CtrChoice Rank>
+struct NotARange {
+  using value_type = int;
+
+  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)
+  {}
+
+  template <class Iter>
+  constexpr NotARange(Iter, Iter)
+  requires (Rank >= CtrChoice::BeginEndPair)
+  {}
+
+  constexpr NotARange()
+  requires (Rank >= CtrChoice::DefaultCtrAndInsert)
+  = default;
+
+  constexpr void push_back(int) {}
+};
+
+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);
+  }
+
+  {
+    using C = NotARange<CtrChoice::BeginEndPair>;
+    [[maybe_unused]] std::same_as<C> decltype(auto) result = std::ranges::to<C>(in);
+  }
+
+  {
+    using C = NotARange<CtrChoice::DefaultCtrAndInsert>;
+    [[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 = {};
+  { // Fill the nested array with incremental values.
+    int x = 0;
+    for (auto& a3 : in) {
+      for (auto& a2 : a3) {
+        for (auto& a1 : a2) {
+          for (int& el : a1) {
+            el = x++;
+          }
+        }
+      }
+    }
+  }
+
+  std::same_as<C4> decltype(auto) result = std::ranges::to<C4>(in);
+
+  assert(result.ctr_choice == CtrChoice::DefaultCtrAndInsert);
+
+  int expected_value = 0;
+  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);
+
+        for (int el : c1) {
+          assert(el == expected_value);
+          ++expected_value;
+        }
+      }
+    }
+  }
+
+  assert((in | std::ranges::to<C4>()) == result);
+}
+
+template <class ElementType>
+struct ContainerWithDirectCtr : Container<ElementType, CtrChoice::DirectCtr> {
+  using Container<ElementType, CtrChoice::DirectCtr>::Container;
+};
+
+template <std::ranges::input_range Range>
+ContainerWithDirectCtr(Range&&) -> ContainerWithDirectCtr<std::ranges::range_value_t<Range>>;
+
+template <std::ranges::input_range Range>
+ContainerWithDirectCtr(Range&&, int, char) -> ContainerWithDirectCtr<std::ranges::range_value_t<Range>>;
+
+template <class ElementType>
+struct ContainerWithFromRangeT : Container<ElementType, CtrChoice::FromRangeT> {
+  using Container<ElementType, CtrChoice::FromRangeT>::Container;
+};
+
+template <std::ranges::input_range Range>
+ContainerWithFromRangeT(std::from_range_t, Range&&) -> ContainerWithFromRangeT<std::ranges::range_value_t<Range>>;
+
+template <std::ranges::input_range Range>
+ContainerWithFromRangeT(std::from_range_t, Range&&, int, char) ->
+    ContainerWithFromRangeT<std::ranges::range_value_t<Range>>;
+
+template <class ElementType>
+struct ContainerWithBeginEndPair : Container<ElementType, CtrChoice::BeginEndPair> {
+  using Container<ElementType, CtrChoice::BeginEndPair>::Container;
+};
+
+template <class Iter>
+ContainerWithBeginEndPair(Iter, Iter) -> ContainerWithBeginEndPair<std::iter_value_t<Iter>>;
+
+template <class Iter>
+ContainerWithBeginEndPair(Iter, Iter, int, char) -> ContainerWithBeginEndPair<std::iter_value_t<Iter>>;
+
+constexpr void test_deduce_expr() {
+  std::array in = {1, 2, 3, 4, 5};
+  int arg1 = 42;
+  char arg2 = 'a';
+
+  { // Case 1 -- can construct directly from the given range.
+    {
+      std::same_as<ContainerWithDirectCtr<int>> decltype(auto) result = std::ranges::to<ContainerWithDirectCtr>(in);
+
+      assert(result.ctr_choice == CtrChoice::DirectCtr);
+      assert(std::ranges::equal(result, in));
+      assert((in | std::ranges::to<ContainerWithDirectCtr>()) == result);
+    }
+
+    { // Extra arguments.
+      std::same_as<ContainerWithDirectCtr<int>> decltype(auto) result =
+          std::ranges::to<ContainerWithDirectCtr>(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);
+      assert((in | std::ranges::to<ContainerWithDirectCtr>(arg1, arg2)) == result);
+    }
+  }
+
+  { // Case 2 -- can construct from the given range using the `from_range_t` tagged constructor.
+    {
+      std::same_as<ContainerWithFromRangeT<int>> decltype(auto) result = std::ranges::to<ContainerWithFromRangeT>(in);
+
+      assert(result.ctr_choice == CtrChoice::FromRangeT);
+      assert(std::ranges::equal(result, in));
+      assert((in | std::ranges::to<ContainerWithFromRangeT>()) == result);
+    }
+
+    { // Extra arguments.
+      std::same_as<ContainerWithFromRangeT<int>> decltype(auto) result =
+          std::ranges::to<ContainerWithFromRangeT>(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);
+      assert((in | std::ranges::to<ContainerWithFromRangeT>(arg1, arg2)) == result);
+    }
+  }
+
+  { // Case 3 -- can construct from a begin-end iterator pair.
+    {
+      std::same_as<ContainerWithBeginEndPair<int>> decltype(auto) result =
+          std::ranges::to<ContainerWithBeginEndPair>(in);
+
+      assert(result.ctr_choice == CtrChoice::BeginEndPair);
+      assert(std::ranges::equal(result, in));
+      assert((in | std::ranges::to<ContainerWithBeginEndPair>()) == result);
+    }
+
+    { // Extra arguments.
+      std::same_as<ContainerWithBeginEndPair<int>> decltype(auto) result =
+          std::ranges::to<ContainerWithBeginEndPair>(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);
+      assert((in | std::ranges::to<ContainerWithBeginEndPair>(arg1, arg2)) == result);
+    }
+  }
+}
+
+constexpr bool test() {
+  test_constraints();
+  test_ctr_choice_order();
+  test_lwg_3785();
+  test_recursive();
+  test_deduce_expr();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.utility/range.utility.conv/to_std_containers.pass.cpp b/libcxx/test/std/ranges/range.utility/range.utility.conv/to_std_containers.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.utility/range.utility.conv/to_std_containers.pass.cpp
@@ -0,0 +1,217 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "test_iterators.h"
+#include "test_range.h"
+#include "type_algorithms.h"
+#include "unwrap_container_adaptor.h"
+
+std::vector<std::vector<int>> ints = {
+  {5, 1, 3, 4, 2},
+  {3},
+  {}
+};
+
+std::vector<std::vector<char>> chars = {
+  {'a', 'b', 'c'},
+  {'a'},
+  {}
+};
+
+std::vector<std::vector<std::pair<const int, int>>> pairs = {
+  {{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 0}},
+  {{1, 2}},
+  {}
+};
+
+template <class From, class To>
+void test_is_equal(std::vector<std::vector<typename From::value_type>> inputs) {
+  for (const auto& in : inputs) {
+    From from(in.begin(), in.end());
+    std::same_as<To> decltype(auto) result = std::ranges::to<To>(from);
+    assert(std::ranges::equal(in, result));
+  }
+}
+
+template <class From, class To>
+void test_is_permutation(std::vector<std::vector<typename From::value_type>> inputs) {
+  for (const auto& in : inputs) {
+    From from(in.begin(), in.end());
+    std::same_as<To> decltype(auto) result = std::ranges::to<To>(in);
+    assert(std::ranges::is_permutation(in, result));
+  }
+}
+
+template <class From, class To>
+void test_is_equal_for_adaptors(std::vector<std::vector<typename From::value_type>> inputs) {
+  for (const auto& in : inputs) {
+    From from(in.begin(), in.end());
+    std::same_as<To> decltype(auto) result = std::ranges::to<To>(in);
+
+    UnwrapAdaptor<From> unwrap_from(std::move(from));
+    UnwrapAdaptor<To> unwrap_to(std::move(result));
+    assert(std::ranges::is_permutation(unwrap_from.get_container(), unwrap_to.get_container()));
+  }
+}
+
+template <class T>
+using sequence_containers = types::type_list<
+    std::vector<T>,
+    std::deque<T>,
+    std::list<T>,
+    std::forward_list<T>
+>;
+
+template <class T>
+using associative_sets = types::type_list<
+    std::set<T>,
+    std::multiset<T>
+>;
+
+template <class K, class V>
+using associative_maps = types::type_list<
+    std::map<K, V>,
+    std::multimap<K, V>
+>;
+
+template <class T>
+using unordered_sets = types::type_list<
+    std::unordered_set<T>,
+    std::unordered_multiset<T>
+>;
+
+template <class K, class V>
+using unordered_maps = types::type_list<
+    std::unordered_map<K, V>,
+    std::unordered_multimap<K, V>
+>;
+
+template <class T>
+using container_adaptors = types::type_list<
+    std::stack<T>,
+    std::queue<T>,
+    std::priority_queue<T>
+>;
+
+template <class T>
+using sequences_and_sets = types::concatenate_t<sequence_containers<T>, associative_sets<T>, unordered_sets<T>>;
+
+template <class K, class V>
+using all_containers = types::concatenate_t<
+    sequence_containers<std::pair<const K, V>>,
+    associative_sets<std::pair<const K, V>>,
+    associative_maps<K, V>,
+    unordered_sets<std::pair<const K, V>>,
+    unordered_maps<K, V>>;
+
+// This is necessary to be able to use `pair`s with unordered sets.
+template <class K, class V>
+struct std::hash<std::pair<const K, V>> {
+  std::size_t operator()(const std::pair<const K, V>& p) const {
+    std::size_t h1 = std::hash<K>{}(p.first);
+    std::size_t h2 = std::hash<V>{}(p.second);
+    return h1 ^ (h2 << 1);
+  }
+};
+
+void test() {
+  { // Conversions always preserving equality.
+    { // sequences <-> sequences
+      types::for_each(sequence_containers<int>{}, []<class From>() {
+        types::for_each(sequence_containers<int>{}, []<class To>() {
+          test_is_equal<From, To>(ints);
+        });
+      });
+
+      types::for_each(sequence_containers<int>{}, []<class From>() {
+        types::for_each(sequence_containers<double>{}, []<class To>() {
+          test_is_equal<From, To>(ints);
+        });
+      });
+    }
+
+    { // sequences <-> string
+      types::for_each(sequence_containers<char>{}, []<class Seq>() {
+        test_is_equal<Seq, std::basic_string<char>>(chars);
+        test_is_equal<std::basic_string<char>, Seq>(chars);
+      });
+    }
+  }
+
+  { // sequences/sets <-> sequences/sets
+    types::for_each(sequences_and_sets<int>{}, []<class From>() {
+      types::for_each(sequences_and_sets<int>{}, []<class To>() {
+        test_is_permutation<From, To>(ints);
+      });
+    });
+
+    types::for_each(sequences_and_sets<int>{}, []<class From>() {
+      types::for_each(sequences_and_sets<double>{}, []<class To>() {
+        test_is_permutation<From, To>(ints);
+      });
+    });
+  }
+
+  { // sequences/sets/maps <-> sequences/sets/maps. Uses `pair` for non-map containers to allow mutual conversion with
+    // map types.
+    types::for_each(all_containers<int, int>{}, []<class From>() {
+      types::for_each(all_containers<int, int>{}, []<class To>() {
+        test_is_permutation<From, To>(pairs);
+      });
+    });
+
+    types::for_each(all_containers<int, int>{}, []<class From>() {
+      types::for_each(all_containers<long, double>{}, []<class To>() {
+        test_is_permutation<From, To>(pairs);
+      });
+    });
+  }
+
+  { // adaptors <-> adaptors
+    types::for_each(container_adaptors<int>{}, []<class From>() {
+      types::for_each(container_adaptors<int>{}, []<class To>() {
+        test_is_equal_for_adaptors<From, To>(ints);
+      });
+    });
+
+    types::for_each(container_adaptors<int>{}, []<class From>() {
+      types::for_each(container_adaptors<double>{}, []<class To>() {
+        test_is_equal_for_adaptors<From, To>(ints);
+      });
+    });
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp
@@ -0,0 +1,131 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "../../../containers/from_range_helpers.h"
+#include "../../../containers/sequences/from_range_sequence_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R>
+//   basic_string(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
+
+std::vector<char> long_string = {
+  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+  'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
+};
+
+template <class Container, class Range, class Alloc>
+concept StringHasFromRangeAllocCtr = requires (Range&& range, const Alloc& alloc) {
+  Container(std::from_range, std::forward<Range>(range), alloc);
+};
+
+constexpr bool test_constraints() {
+  // (from_range, range)
+  //
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<std::string, InputRange<char>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<std::string, InputRange<int>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<std::string, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotDerivedFrom>);
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotInputOrOutputIterator>);
+
+  // (from_range, range, alloc)
+  //
+  // Input range with the same value type.
+  using Alloc = test_allocator<char>;
+  using StringWithAlloc = std::basic_string<char, std::char_traits<char>, Alloc>;
+  static_assert(StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<char>, Alloc>);
+  // Input range with a convertible value type.
+  static_assert(StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<int>, Alloc>);
+  // Input range with a non-convertible value type.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<Empty>, Alloc>);
+  // Not an input range.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotDerivedFrom, Alloc>);
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotIndirectlyReadable, Alloc>);
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotInputOrOutputIterator, Alloc>);
+  // Not an allocator.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<char>, Empty>);
+
+  return true;
+}
+
+template <class Iter,
+          class Sent,
+          class Alloc>
+constexpr void test_with_input(std::vector<char> input) {
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    std::string c(std::from_range, in);
+
+    LIBCPP_ASSERT(c.__invariants());
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+  }
+
+  { // (range, allocator)
+    Alloc alloc;
+    std::basic_string<char, std::char_traits<char>, Alloc> c(std::from_range, in, alloc);
+
+    LIBCPP_ASSERT(c.__invariants());
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+  }
+}
+
+void test_string_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(std::from_range, long_string, alloc);
+    assert(false); // The constructor call should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<char>([]<class Iter, class Sent, class Alloc>() {
+    // Shorter input -- SSO.
+    test_with_input<Iter, Sent, Alloc>({'a', 'b', 'c', 'd', 'e'});
+
+    // Longer input -- no SSO.
+    test_with_input<Iter, Sent, Alloc>(long_string);
+
+    // Empty input.
+    test_with_input<Iter, Sent, Alloc>({});
+
+    // Single-element input.
+    test_with_input<Iter, Sent, Alloc>({'a'});
+  });
+
+  static_assert(test_constraints());
+
+  // Note: `test_exception_safety_throwing_copy` doesn't apply because copying a `char` cannot throw.
+  test_string_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.cons/from_range_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/from_range_deduction.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.cons/from_range_deduction.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<ranges::input_range R,
+//          class Allocator = allocator<ranges::range_value_t<R>>>
+//   basic_string(from_range_t, R&&, Allocator = Allocator())
+//     -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
+//                     Allocator>; // C++23
+//
+// The deduction guide shall not participate in overload resolution if Allocator
+// is a type that does not qualify as an allocator (in addition to the `input_range` concept being satisfied by `R`).
+
+#include <array>
+#include <string>
+
+#include "deduction_guides_sfinae_checks.h"
+#include "test_allocator.h"
+
+int main(int, char**) {
+  using Char = char16_t;
+
+  {
+    std::basic_string c(std::from_range, std::array<Char, 0>());
+    static_assert(std::is_same_v<decltype(c), std::basic_string<Char>>);
+  }
+
+  {
+    using Alloc = test_allocator<Char>;
+    std::basic_string c(std::from_range, std::array<Char, 0>(), Alloc());
+    static_assert(std::is_same_v<decltype(c), std::basic_string<Char, std::char_traits<Char>, Alloc>>);
+  }
+
+  // Note: defining `value_type` is a workaround because one of the deduction guides will end up instantiating
+  // `basic_string`, and that would fail with a hard error if the given allocator doesn't define `value_type`.
+  struct BadAlloc { using value_type = char; };
+  SequenceContainerDeductionGuidesSfinaeAway<std::basic_string, std::basic_string<char>, BadAlloc>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
@@ -47,6 +47,7 @@
 static_assert( CanDeduce<char*, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnIterator, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnInputIterator, std::allocator<char16_t>>::value);
+static_assert(!CanDeduce<char*, NotAnAllocator<char>>::value);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert( CanDeduce<wchar_t*, std::allocator<wchar_t>>::value);
 static_assert(!CanDeduce<wchar_t const*, NotAnAllocator<wchar_t>>::value);
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_range.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<charT> R>
+//   constexpr basic_string& append_range(R&& rg); // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+void test_string_append_range_return_value() {
+  std::string c;
+  static_assert(std::is_lvalue_reference_v<decltype(
+      c.append_range(FullContainer_Begin_EmptyRange<char>.input)
+  )>);
+  assert(&c.append_range(FullContainer_Begin_EmptyRange<char>.input) == &c);
+  assert(&c.append_range(FullContainer_Begin_OneElementRange<char>.input) == &c);
+  assert(&c.append_range(FullContainer_Begin_MidRange<char>.input) == &c);
+  assert(&c.append_range(FullContainer_Begin_LongRange<char>.input) == &c);
+}
+
+void test_string_append_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+  std::string in(64, 'a');
+
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+    c.append_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+// Tested cases:
+// - different kinds of insertions (appending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_append_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_append_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  test_string_append_range_return_value();
+
+  // Note: `test_append_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  test_string_append_range_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/assign_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/assign_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/assign_range.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<charT> R>
+//   constexpr basic_string& assign_range(R&& rg); // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+void test_string_assign_range_return_value() {
+  std::string c;
+  static_assert(std::is_lvalue_reference_v<decltype(
+      c.assign_range(FullContainer_Begin_EmptyRange<char>.input)
+  )>);
+  assert(&c.assign_range(FullContainer_Begin_EmptyRange<char>.input) == &c);
+  assert(&c.assign_range(FullContainer_Begin_OneElementRange<char>.input) == &c);
+  assert(&c.assign_range(FullContainer_Begin_MidRange<char>.input) == &c);
+  assert(&c.assign_range(FullContainer_Begin_LongRange<char>.input) == &c);
+}
+
+void test_string_assign_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+  std::string in(64, 'a');
+
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+    c.assign_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+// Tested cases:
+// - different kinds of assignments (assigning an {empty/one-element/mid-sized/long range} to an
+//   {empty/one-element/full} container);
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_assign_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_assign_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  test_string_assign_range_return_value();
+
+  // Note: `test_assign_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  test_string_assign_range_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/insert_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/insert_range.pass.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<container-compatible-range<charT> R>
+//   constexpr iterator insert_range(const_iterator p, R&& rg);                                // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+void test_string_insert_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+  std::string in(64, 'a');
+
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+    c.insert_range(c.end(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+// Tested cases:
+// - different kinds of insertions (inserting an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container at the {beginning/middle/end});
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_insert_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  // Note: `test_insert_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  test_string_insert_range_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_range.pass.cpp
@@ -0,0 +1,743 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=10000000
+
+// template<container-compatible-range<charT> R>
+//   constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg); // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+using StrBuffer = Buffer<char, 96>;
+
+struct TestCaseReplacement {
+  StrBuffer initial;
+  std::size_t from = 0;
+  std::size_t to = 0;
+  StrBuffer input;
+  StrBuffer expected;
+};
+
+// Permutation matrix:
+// - initial string: empty / one-element / n elements;
+// - cut starts from: beginning / middle / end;
+// - cut size: empty / one-element / several elements / until the end;
+// - input range: empty / one-element / middle-sized / long.
+
+// Empty string.
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_EmptyRange {
+  .initial = "", .from = 0, .to = 0, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_OneElementRange {
+  .initial = "", .from = 0, .to = 0, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_MidRange {
+  .initial = "", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_LongRange {
+  .initial = "", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// One-element string.
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_EmptyRange {
+  .initial = "B", .from = 0, .to = 0, .input = "", .expected = "B"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_OneElementRange {
+  .initial = "B", .from = 0, .to = 0, .input = "a", .expected = "aB"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_MidRange {
+  .initial = "B", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiouB"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_LongRange {
+  .initial = "B", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789B"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_EmptyRange {
+  .initial = "B", .from = 0, .to = 1, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_OneElementRange {
+  .initial = "B", .from = 0, .to = 1, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_MidRange {
+  .initial = "B", .from = 0, .to = 1, .input = "aeiou", .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_LongRange {
+  .initial = "B", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_EmptyRange {
+  .initial = "B", .from = 1, .to = 1, .input = "", .expected = "B"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_OneElementRange {
+  .initial = "B", .from = 1, .to = 1, .input = "a", .expected = "Ba"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_MidRange {
+  .initial = "B", .from = 1, .to = 1, .input = "aeiou", .expected = "Baeiou"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_LongRange {
+  .initial = "B", .from = 1, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "Babcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Short string (using SSO).
+
+// Replace at the beginning.
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "a", .expected = "a_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiou_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "", .expected = "BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "a", .expected = "aBCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "aeiou", .expected = "aeiouBCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "", .expected = "DFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "a", .expected = "aDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "aeiou", .expected = "aeiouDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789DFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "aeiou", .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace in the middle.
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "a", .expected = "_BCDaFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "aeiou", .expected = "_BCDaeiouFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789FGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "", .expected = "_BCDGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "a", .expected = "_BCDaGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "aeiou", .expected = "_BCDaeiouGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789GHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "", .expected = "_BCDJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "a", .expected = "_BCDaJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "aeiou", .expected = "_BCDaeiouJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789J_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "", .expected = "_BCD"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "a", .expected = "_BCDa"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "aeiou", .expected = "_BCDaeiou"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace at the end.
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "a", .expected = "_BCDFGHJ_a"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "aeiou", .expected = "_BCDFGHJ_aeiou"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDFGHJ_abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Long string (no SSO).
+
+// Replace at the beginning.
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "a",
+  .expected = "a_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "aeiou",
+  .expected = "aeiou_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "",
+  .expected = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "a",
+  .expected = "aABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "aeiou",
+  .expected = "aeiouABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "",
+  .expected = "CDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "a",
+  .expected = "aCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "aeiou",
+  .expected = "aeiouCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789CDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "",
+  .expected = ""
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "a",
+  .expected = "a"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "aeiou",
+  .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace in the middle.
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789RSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789STUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789UVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQ"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQa"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiou"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace at the end.
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_a"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_aeiou"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+template <class Iter, class Sent, class Alloc>
+constexpr void test_string_replace_with_range() {
+  auto test = [&](const TestCaseReplacement& test_case) {
+    using Container = std::basic_string<char, std::char_traits<char>, Alloc>;
+
+    auto get_pos = [](auto& c, auto index) { return std::ranges::next(c.begin(), index); };
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+    auto from = get_pos(c, test_case.from);
+    auto to = get_pos(c, test_case.to);
+
+    Container& result = c.replace_with_range(from, to, in);
+    assert(&result == &c);
+    LIBCPP_ASSERT(c.__invariants());
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty string.
+    // empty_str.replace_with_range(end, end, empty_range)
+    assert(test(EmptyString_End_EmptyCut_EmptyRange));
+    // empty_str.replace_with_range(end, end, one_element_range)
+    assert(test(EmptyString_End_EmptyCut_OneElementRange));
+    // empty_str.replace_with_range(end, end, mid_range)
+    assert(test(EmptyString_End_EmptyCut_MidRange));
+    // empty_str.replace_with_range(end, end, long_range)
+    assert(test(EmptyString_End_EmptyCut_LongRange));
+  }
+
+  { // One-element string.
+    // one_element_str.replace_with_range(begin, begin, empty_range)
+    assert(test(OneElementString_Begin_EmptyCut_EmptyRange));
+    // one_element_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(OneElementString_Begin_EmptyCut_OneElementRange));
+    // one_element_str.replace_with_range(begin, begin, mid_range)
+    assert(test(OneElementString_Begin_EmptyCut_MidRange));
+    // one_element_str.replace_with_range(begin, begin, long_range)
+    assert(test(OneElementString_Begin_EmptyCut_LongRange));
+    // one_element_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(OneElementString_Begin_OneElementCut_EmptyRange));
+    // one_element_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(OneElementString_Begin_OneElementCut_OneElementRange));
+    // one_element_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(OneElementString_Begin_OneElementCut_MidRange));
+    // one_element_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(OneElementString_Begin_OneElementCut_LongRange));
+    // one_element_str.replace_with_range(end, end, empty_range)
+    assert(test(OneElementString_End_EmptyCut_EmptyRange));
+    // one_element_str.replace_with_range(end, end, one_element_range)
+    assert(test(OneElementString_End_EmptyCut_OneElementRange));
+    // one_element_str.replace_with_range(end, end, mid_range)
+    assert(test(OneElementString_End_EmptyCut_MidRange));
+    // one_element_str.replace_with_range(end, end, long_range)
+    assert(test(OneElementString_End_EmptyCut_LongRange));
+  }
+
+  { // Short string.
+    // Replace at the beginning.
+
+    // short_str.replace_with_range(begin, begin, empty_range)
+    assert(test(ShortString_Begin_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(ShortString_Begin_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin, mid_range)
+    assert(test(ShortString_Begin_EmptyCut_MidRange));
+    // short_str.replace_with_range(begin, begin, long_range)
+    assert(test(ShortString_Begin_EmptyCut_LongRange));
+    // short_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(ShortString_Begin_OneElementCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(ShortString_Begin_OneElementCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(ShortString_Begin_OneElementCut_MidRange));
+    // short_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(ShortString_Begin_OneElementCut_LongRange));
+    // short_str.replace_with_range(begin, begin + 3, empty_range)
+    assert(test(ShortString_Begin_MidSizedCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin + 3, one_element_range)
+    assert(test(ShortString_Begin_MidSizedCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin + 3, mid_range)
+    assert(test(ShortString_Begin_MidSizedCut_MidRange));
+    // short_str.replace_with_range(begin, begin + 3, long_range)
+    assert(test(ShortString_Begin_MidSizedCut_LongRange));
+    // short_str.replace_with_range(begin, end, empty_range)
+    assert(test(ShortString_Begin_CutToEnd_EmptyRange));
+    // short_str.replace_with_range(begin, end, one_element_range)
+    assert(test(ShortString_Begin_CutToEnd_OneElementRange));
+    // short_str.replace_with_range(begin, end, mid_range)
+    assert(test(ShortString_Begin_CutToEnd_MidRange));
+    // short_str.replace_with_range(begin, end, long_range)
+    assert(test(ShortString_Begin_CutToEnd_LongRange));
+
+    // Replace in the middle.
+
+    // short_str.replace_with_range(mid, mid, empty_range)
+    assert(test(ShortString_Mid_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid, one_element_range)
+    assert(test(ShortString_Mid_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid, mid_range)
+    assert(test(ShortString_Mid_EmptyCut_MidRange));
+    // short_str.replace_with_range(mid, mid, long_range)
+    assert(test(ShortString_Mid_EmptyCut_LongRange));
+    // short_str.replace_with_range(mid, mid + 1, empty_range)
+    assert(test(ShortString_Mid_OneElementCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid + 1, one_element_range)
+    assert(test(ShortString_Mid_OneElementCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid + 1, mid_range)
+    assert(test(ShortString_Mid_OneElementCut_MidRange));
+    // short_str.replace_with_range(mid, mid + 1, long_range)
+    assert(test(ShortString_Mid_OneElementCut_LongRange));
+    // short_str.replace_with_range(mid, mid + 3, empty_range)
+    assert(test(ShortString_Mid_MidSizedCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid + 3, one_element_range)
+    assert(test(ShortString_Mid_MidSizedCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid + 3, mid_range)
+    assert(test(ShortString_Mid_MidSizedCut_MidRange));
+    // short_str.replace_with_range(mid, mid + 3, long_range)
+    assert(test(ShortString_Mid_MidSizedCut_LongRange));
+    // short_str.replace_with_range(mid, end, empty_range)
+    assert(test(ShortString_Mid_CutToEnd_EmptyRange));
+    // short_str.replace_with_range(mid, end, one_element_range)
+    assert(test(ShortString_Mid_CutToEnd_OneElementRange));
+    // short_str.replace_with_range(mid, end, mid_range)
+    assert(test(ShortString_Mid_CutToEnd_MidRange));
+    // short_str.replace_with_range(mid, end, long_range)
+    assert(test(ShortString_Mid_CutToEnd_LongRange));
+
+    // Replace at the end.
+
+    // short_str.replace_with_range(end, end, empty_range)
+    assert(test(ShortString_End_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(end, end, one_element_range)
+    assert(test(ShortString_End_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(end, end, mid_range)
+    assert(test(ShortString_End_EmptyCut_MidRange));
+    // short_str.replace_with_range(end, end, long_range)
+    assert(test(ShortString_End_EmptyCut_LongRange));
+  }
+
+  { // Long string.
+    // Replace at the beginning.
+
+    // long_str.replace_with_range(begin, begin, empty_range)
+    assert(test(LongString_Begin_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(LongString_Begin_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin, mid_range)
+    assert(test(LongString_Begin_EmptyCut_MidRange));
+    // long_str.replace_with_range(begin, begin, long_range)
+    assert(test(LongString_Begin_EmptyCut_LongRange));
+    // long_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(LongString_Begin_OneElementCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(LongString_Begin_OneElementCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(LongString_Begin_OneElementCut_MidRange));
+    // long_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(LongString_Begin_OneElementCut_LongRange));
+    // long_str.replace_with_range(begin, begin + 3, empty_range)
+    assert(test(LongString_Begin_MidSizedCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin + 3, one_element_range)
+    assert(test(LongString_Begin_MidSizedCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin + 3, mid_range)
+    assert(test(LongString_Begin_MidSizedCut_MidRange));
+    // long_str.replace_with_range(begin, begin + 3, long_range)
+    assert(test(LongString_Begin_MidSizedCut_LongRange));
+    // long_str.replace_with_range(begin, end, empty_range)
+    assert(test(LongString_Begin_CutToEnd_EmptyRange));
+    // long_str.replace_with_range(begin, end, one_element_range)
+    assert(test(LongString_Begin_CutToEnd_OneElementRange));
+    // long_str.replace_with_range(begin, end, mid_range)
+    assert(test(LongString_Begin_CutToEnd_MidRange));
+    // long_str.replace_with_range(begin, end, long_range)
+    assert(test(LongString_Begin_CutToEnd_LongRange));
+
+    // Replace in the middle.
+
+    // long_str.replace_with_range(mid, mid, empty_range)
+    assert(test(LongString_Mid_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid, one_element_range)
+    assert(test(LongString_Mid_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid, mid_range)
+    assert(test(LongString_Mid_EmptyCut_MidRange));
+    // long_str.replace_with_range(mid, mid, long_range)
+    assert(test(LongString_Mid_EmptyCut_LongRange));
+    // long_str.replace_with_range(mid, mid + 1, empty_range)
+    assert(test(LongString_Mid_OneElementCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid + 1, one_element_range)
+    assert(test(LongString_Mid_OneElementCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid + 1, mid_range)
+    assert(test(LongString_Mid_OneElementCut_MidRange));
+    // long_str.replace_with_range(mid, mid + 1, long_range)
+    assert(test(LongString_Mid_OneElementCut_LongRange));
+    // long_str.replace_with_range(mid, mid + 3, empty_range)
+    assert(test(LongString_Mid_MidSizedCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid + 3, one_element_range)
+    assert(test(LongString_Mid_MidSizedCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid + 3, mid_range)
+    assert(test(LongString_Mid_MidSizedCut_MidRange));
+    // long_str.replace_with_range(mid, mid + 3, long_range)
+    assert(test(LongString_Mid_MidSizedCut_LongRange));
+    // long_str.replace_with_range(mid, end, empty_range)
+    assert(test(LongString_Mid_CutToEnd_EmptyRange));
+    // long_str.replace_with_range(mid, end, one_element_range)
+    assert(test(LongString_Mid_CutToEnd_OneElementRange));
+    // long_str.replace_with_range(mid, end, mid_range)
+    assert(test(LongString_Mid_CutToEnd_MidRange));
+    // long_str.replace_with_range(mid, end, long_range)
+    assert(test(LongString_Mid_CutToEnd_LongRange));
+
+    // Replace at the end.
+
+    // long_str.replace_with_range(end, end, empty_range)
+    assert(test(LongString_End_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(end, end, one_element_range)
+    assert(test(LongString_End_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(end, end, mid_range)
+    assert(test(LongString_End_EmptyCut_MidRange));
+    // long_str.replace_with_range(end, end, long_range)
+    assert(test(LongString_End_EmptyCut_LongRange));
+  }
+}
+
+void test_string_replace_with_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+  std::string in(64, 'a');
+
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+    c.replace_with_range(c.end(), c.end(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+constexpr bool test_constexpr() {
+  for_all_iterators_and_allocators_constexpr<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_string_replace_with_range<Iter, Sent, Alloc>();
+  });
+
+  return true;
+}
+
+// Tested cases:
+// - different kinds of replacements (varying the size of the initial string, the cut point and the cut size, and the
+//   size of the input range);
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  for_all_iterators_and_allocators_constexpr<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_string_replace_with_range<Iter, Sent, Alloc>();
+  });
+  static_assert(test_constexpr());
+
+  // Note: `test_string_replace_with_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot
+  // throw.
+  test_string_replace_with_range_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
@@ -1,5 +1,5 @@
-//===----------------------------------------------------------------------===//
 //
+//===----------------------------------------------------------------------===//
 // 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
diff --git a/libcxx/test/support/deduction_guides_sfinae_checks.h b/libcxx/test/support/deduction_guides_sfinae_checks.h
--- a/libcxx/test/support/deduction_guides_sfinae_checks.h
+++ b/libcxx/test/support/deduction_guides_sfinae_checks.h
@@ -18,6 +18,25 @@
 #include <utility>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 23
+#include "almost_satisfies_types.h"
+#endif
+
+#if TEST_STD_VER >= 23
+
+template <class T>
+struct RangeT {
+  T* begin();
+  T* end();
+};
+static_assert(std::ranges::input_range<RangeT<int>>);
+
+template <class T>
+using BadRangeT = InputRangeNotDerivedFromGeneric<T>;
+static_assert(std::ranges::range<BadRangeT<int>>);
+static_assert(!std::ranges::input_range<BadRangeT<int>>);
+
+#endif
 
 // `SFINAEs_away` template variable checks whether the template arguments for
 // a given template class `Instantiated` can be deduced from the given
@@ -34,17 +53,20 @@
 constexpr bool SFINAEs_away =
     decltype(SFINAEs_away_impl<Instantiated, CtrArgs...>(0))::value;
 
+struct Empty {};
+
 // For sequence containers the deduction guides should be SFINAE'd away when
 // given:
 // - "bad" input iterators (that is, a type not qualifying as an input
 //   iterator);
-// - a bad allocator.
-template<template<typename ...> class Container, typename InstantiatedContainer>
+// - a bad allocator;
+// - a range not satisfying the `input_range` concept.
+template<template<typename ...> class Container, typename InstantiatedContainer, typename BadAlloc = Empty>
 constexpr void SequenceContainerDeductionGuidesSfinaeAway() {
-  using Alloc = std::allocator<int>;
-  using Iter = int*;
+  using T = typename InstantiatedContainer::value_type;
+  using Alloc = std::allocator<T>;
+  using Iter = T*;
 
-  struct BadAlloc {};
   // Note: the only requirement in the Standard is that integral types cannot be
   // considered input iterators; however, this doesn't work for sequence
   // containers because they have constructors of the form `(size_type count,
@@ -70,6 +92,68 @@
   //
   // Cannot deduce from (alloc)
   static_assert(SFINAEs_away<Container, Alloc>);
+
+#if TEST_STD_VER >= 23
+  using BadRange = BadRangeT<T>;
+
+  // (from_range, range)
+  //
+  // Cannot deduce from (BAD_range)
+  static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);
+
+  // (from_range, range, alloc)
+  //
+  // Cannot deduce from (range, BAD_alloc)
+  static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);
+#endif
+}
+
+// Deduction guides should be SFINAE'd away when given:
+// - a "bad" allocator (that is, a type not qualifying as an allocator);
+// - an allocator instead of a container;
+// - an allocator and a container that uses a different allocator;
+// - a range not satisfying the `input_range` concept.
+template<template<typename ...> class Container, typename InstantiatedContainer>
+constexpr void ContainerAdaptorDeductionGuidesSfinaeAway() {
+  using T = typename InstantiatedContainer::value_type;
+  using Alloc = std::allocator<T>;
+  using Iter = T*;
+
+  using BadIter = int;
+  using BadAlloc = Empty;
+
+  // (container) -- no constraints.
+
+  // (container, alloc)
+  //
+  // Cannot deduce from (container, BAD_alloc)
+  static_assert(SFINAEs_away<Container, std::vector<T>, BadAlloc>);
+
+  // (iter, iter)
+  //
+  // Cannot deduce from (BAD_iter, BAD_iter)
+  LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, BadIter, BadIter>);
+
+#if TEST_STD_VER >= 23
+  using BadRange = BadRangeT<T>;
+
+  // (iter, iter, alloc)
+  //
+  // Cannot deduce from (BAD_iter, BAD_iter, alloc)
+  LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, BadIter, BadIter, Alloc>);
+  // Cannot deduce from (iter, iter, BAD_alloc)
+  static_assert(SFINAEs_away<Container, Iter, Iter, BadAlloc>);
+
+  // (from_range, range)
+  //
+  // Cannot deduce from (BAD_range)
+  static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);
+
+  // (from_range, range, alloc)
+  //
+  // Cannot deduce from (range, BAD_alloc)
+  static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);
+#endif
 }
 
 // For associative containers the deduction guides should be SFINAE'd away when
@@ -77,8 +161,8 @@
 // - "bad" input iterators (that is, a type not qualifying as an input
 //   iterator);
 // - a bad allocator;
-// - an allocator in place of a comparator.
-
+// - an allocator in place of a comparator;
+// - a range not satisfying the `input_range` concept.
 template<template<typename ...> class Container, typename InstantiatedContainer>
 constexpr void AssociativeContainerDeductionGuidesSfinaeAway() {
   using ValueType = typename InstantiatedContainer::value_type;
@@ -140,6 +224,35 @@
   // Note: (init_list, BAD_alloc) is interpreted as (init_list, comp) instead
   // and fails upon instantiation. There is no requirement to SFINAE away bad
   // comparators.
+
+#if TEST_STD_VER >= 23
+  using Range = RangeT<ValueType>;
+  using BadRange = BadRangeT<ValueType>;
+
+  // (from_range, range)
+  //
+  // Cannot deduce from (from_range, BAD_range)
+  static_assert(SFINAEs_away<Container, BadRange>);
+
+  // (from_range, range, comp)
+  //
+  // Cannot deduce from (from_range, BAD_range, comp)
+  static_assert(SFINAEs_away<Container, BadRange, Comp>);
+
+  // (from_range, range, comp, alloc)
+  //
+  // Cannot deduce from (from_range, BAD_range, comp, alloc)
+  static_assert(SFINAEs_away<Container, BadRange, Comp, Alloc>);
+  // Cannot deduce from (from_range, range, comp, BAD_alloc)
+  static_assert(SFINAEs_away<Container, Range, Comp, BadAlloc>);
+
+  // (from_range, range, alloc)
+  //
+  // Cannot deduce from (from_range, BAD_range, alloc)
+  static_assert(SFINAEs_away<Container, BadRange, Alloc>);
+  // Cannot deduce from (from_range, range, BAD_alloc)
+  static_assert(SFINAEs_away<Container, Range, BadAlloc>);
+#endif
 }
 
 // For unordered containers the deduction guides should be SFINAE'd away when
@@ -149,7 +262,8 @@
 // - a bad allocator;
 // - a bad hash functor (an integral type in place of a hash);
 // - an allocator in place of a hash functor;
-// - an allocator in place of a predicate.
+// - an allocator in place of a predicate;
+// - a range not satisfying the `input_range` concept.
 template<template<typename ...> class Container, typename InstantiatedContainer>
 constexpr void UnorderedContainerDeductionGuidesSfinaeAway() {
   using ValueType = typename InstantiatedContainer::value_type;
@@ -307,6 +421,67 @@
   //
   // Cannot deduce from (init_list, BAD_alloc)
   static_assert(SFINAEs_away<Container, InitList, BadAlloc>);
+
+#if TEST_STD_VER >= 23
+  using Range = RangeT<ValueType>;
+  using BadRange = BadRangeT<ValueType>;
+
+  // (from_range, range)
+  //
+  // Cannot deduce from (from_range, BAD_range)
+  static_assert(SFINAEs_away<Container, BadRange>);
+
+  // (from_range, range, n)
+  //
+  // Cannot deduce from (from_range, BAD_range, n)
+  static_assert(SFINAEs_away<Container, BadRange, std::size_t>);
+
+  // (from_range, range, n, hash)
+  //
+  // Cannot deduce from (from_range, BAD_range, n, hash)
+  static_assert(SFINAEs_away<Container, BadRange, std::size_t, Hash>);
+  // Cannot deduce from (from_range, range, n, BAD_hash)
+  static_assert(SFINAEs_away<Container, Range, std::size_t, BadHash>);
+
+  // (from_range, range, n, hash, pred)
+  //
+  // Cannot deduce from (from_range, BAD_range, n, hash, pred)
+  static_assert(SFINAEs_away<Container, BadRange, std::size_t, Hash, Pred>);
+  // Cannot deduce from (from_range, range, n, BAD_hash, pred)
+  static_assert(SFINAEs_away<Container, Range, std::size_t, BadHash, Pred>);
+
+  // (from_range, range, n, hash, pred, alloc)
+  //
+  // Cannot deduce from (from_range, BAD_range, n, hash, pred, alloc)
+  static_assert(SFINAEs_away<Container, BadRange, std::size_t, Hash, Pred, Alloc>);
+  // Cannot deduce from (from_range, range, n, BAD_hash, pred, alloc)
+  static_assert(SFINAEs_away<Container, Range, std::size_t, BadHash, Pred, Alloc>);
+  // Cannot deduce from (from_range, range, n, hash, pred, BAD_alloc)
+  static_assert(SFINAEs_away<Container, Range, std::size_t, Hash, Pred, BadAlloc>);
+
+  // (from_range, range, n, alloc)
+  //
+  // Cannot deduce from (from_range, BAD_range, n, alloc)
+  static_assert(SFINAEs_away<Container, BadRange, std::size_t, Alloc>);
+  // Cannot deduce from (from_range, range, n, BAD_alloc)
+  static_assert(SFINAEs_away<Container, Range, std::size_t, BadAlloc>);
+
+  // (from_range, range, alloc)
+  //
+  // Cannot deduce from (from_range, BAD_range, alloc)
+  static_assert(SFINAEs_away<Container, BadRange, Alloc>);
+  // Cannot deduce from (from_range, range, BAD_alloc)
+  static_assert(SFINAEs_away<Container, Range, BadAlloc>);
+
+  // (from_range, range, n, hash, alloc)
+  //
+  // Cannot deduce from (from_range, BAD_range, n, hash, alloc)
+  static_assert(SFINAEs_away<Container, BadRange, std::size_t, Hash, Alloc>);
+  // Cannot deduce from (from_range, range, n, BAD_hash, alloc)
+  static_assert(SFINAEs_away<Container, Range, std::size_t, BadHash, Alloc>);
+  // Cannot deduce from (from_range, range, n, hash, BAD_alloc)
+  static_assert(SFINAEs_away<Container, Range, std::size_t, Hash, BadAlloc>);
+#endif
 }
 
 #endif // TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H
diff --git a/libcxx/test/support/unwrap_container_adaptor.h b/libcxx/test/support/unwrap_container_adaptor.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/support/unwrap_container_adaptor.h
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_UNWRAP_CONTAINER_ADAPTOR_H
+#define SUPPORT_UNWRAP_CONTAINER_ADAPTOR_H
+
+// Allows accessing the underlying container of the given adaptor.
+template <class Adaptor>
+struct UnwrapAdaptor : Adaptor {
+  UnwrapAdaptor() = default;
+
+  UnwrapAdaptor(Adaptor&& adaptor) : Adaptor(std::move(adaptor)) {}
+  // `c` is a protected member variable of the base class.
+  decltype(auto) get_container() {
+    return (UnwrapAdaptor::c); // Put into parentheses to make sure the function returns a reference.
+  }
+
+  // TODO: make this work pre-C++20.
+  decltype(auto) get_comparator()
+  requires requires {
+    UnwrapAdaptor::c;
+  } {
+    return (UnwrapAdaptor::comp); // Put into parentheses to make sure the function returns a reference.
+  }
+};
+
+#endif // SUPPORT_UNWRAP_CONTAINER_ADAPTOR_H
diff --git a/libcxx/utils/data/ignore_format.txt b/libcxx/utils/data/ignore_format.txt
--- a/libcxx/utils/data/ignore_format.txt
+++ b/libcxx/utils/data/ignore_format.txt
@@ -567,6 +567,7 @@
 libcxx/include/__ranges/all.h
 libcxx/include/__ranges/common_view.h
 libcxx/include/__ranges/concepts.h
+libcxx/include/__ranges/container_compatible_range.h
 libcxx/include/__ranges/copyable_box.h
 libcxx/include/__ranges/counted.h
 libcxx/include/__ranges/data.h
@@ -590,6 +591,8 @@
 libcxx/include/__ranges/size.h
 libcxx/include/__ranges/subrange.h
 libcxx/include/__ranges/take_view.h
+libcxx/include/__ranges/take_while_view.h
+libcxx/include/__ranges/to.h
 libcxx/include/__ranges/transform_view.h
 libcxx/include/__ranges/view_interface.h
 libcxx/include/__ranges/views.h
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
@@ -586,8 +586,7 @@
   }, {
     "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,
+    "headers": ["deque", "forward_list", "list", "map", "queue", "ranges", "set", "stack", "string", "unordered_map", "unordered_set", "vector"],
   }, {
     "name": "__cpp_lib_ranges_zip",
     "values": { "c++2b": 202110 },